Grcov report - isle

1

// GENERATED BY ISLE. DO NOT EDIT!

2

//

3

// Generated automatically from the instruction-selection DSL code in:

4

// - src/prelude.isle

5

// - src/prelude_lower.isle

6

// - src/isa/x64/inst.isle

7

// - src/isa/x64/lower.isle

8

// - /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_lower.isle

9

10

use super::*; // Pulls in all external types.

11

use std::marker::PhantomData;

12

13

/// Context during lowering: an implementation of this trait

14

/// must be provided with all external constructors and extractors.

15

/// A mutable borrow is passed along through all lowering logic.

16

pub trait Context {

17

    fn unit(&mut self) -> Unit;

18

    fn value_type(&mut self, arg0: Value) -> Type;

19

    fn u32_nonnegative(&mut self, arg0: u32) -> Option<u32>;

20

    fn offset32(&mut self, arg0: Offset32) -> i32;

21

    fn u32_lteq(&mut self, arg0: u32, arg1: u32) -> Option<Unit>;

22

    fn u8_lteq(&mut self, arg0: u8, arg1: u8) -> Option<Unit>;

23

    fn u8_lt(&mut self, arg0: u8, arg1: u8) -> Option<Unit>;

24

    fn simm32(&mut self, arg0: Imm64) -> Option<i32>;

25

    fn uimm8(&mut self, arg0: Imm64) -> Option<u8>;

26

    fn u8_as_i8(&mut self, arg0: u8) -> i8;

27

    fn u8_as_u32(&mut self, arg0: u8) -> u32;

28

    fn u8_as_u64(&mut self, arg0: u8) -> u64;

29

    fn u16_as_u64(&mut self, arg0: u16) -> u64;

30

    fn u32_as_u64(&mut self, arg0: u32) -> u64;

31

    fn i32_as_i64(&mut self, arg0: i32) -> i64;

32

    fn i64_as_u64(&mut self, arg0: i64) -> u64;

33

    fn i64_neg(&mut self, arg0: i64) -> i64;

34

    fn u128_as_u64(&mut self, arg0: u128) -> Option<u64>;

35

    fn u64_as_u32(&mut self, arg0: u64) -> Option<u32>;

36

    fn u64_as_i32(&mut self, arg0: u64) -> i32;

37

    fn u8_and(&mut self, arg0: u8, arg1: u8) -> u8;

38

    fn u8_shl(&mut self, arg0: u8, arg1: u8) -> u8;

39

    fn u8_shr(&mut self, arg0: u8, arg1: u8) -> u8;

40

    fn u8_sub(&mut self, arg0: u8, arg1: u8) -> u8;

41

    fn u32_add(&mut self, arg0: u32, arg1: u32) -> u32;

42

    fn u32_sub(&mut self, arg0: u32, arg1: u32) -> u32;

43

    fn u32_and(&mut self, arg0: u32, arg1: u32) -> u32;

44

    fn s32_add_fallible(&mut self, arg0: i32, arg1: i32) -> Option<i32>;

45

    fn u64_add(&mut self, arg0: u64, arg1: u64) -> u64;

46

    fn u64_sub(&mut self, arg0: u64, arg1: u64) -> u64;

47

    fn u64_mul(&mut self, arg0: u64, arg1: u64) -> u64;

48

    fn u64_sdiv(&mut self, arg0: u64, arg1: u64) -> Option<u64>;

49

    fn u64_udiv(&mut self, arg0: u64, arg1: u64) -> Option<u64>;

50

    fn u64_and(&mut self, arg0: u64, arg1: u64) -> u64;

51

    fn u64_or(&mut self, arg0: u64, arg1: u64) -> u64;

52

    fn u64_xor(&mut self, arg0: u64, arg1: u64) -> u64;

53

    fn u64_shl(&mut self, arg0: u64, arg1: u64) -> u64;

54

    fn imm64_shl(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;

55

    fn imm64_ushr(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;

56

    fn imm64_sshr(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;

57

    fn u64_not(&mut self, arg0: u64) -> u64;

58

    fn u64_eq(&mut self, arg0: u64, arg1: u64) -> bool;

59

    fn u64_le(&mut self, arg0: u64, arg1: u64) -> bool;

60

    fn u64_lt(&mut self, arg0: u64, arg1: u64) -> bool;

61

    fn i64_shr(&mut self, arg0: i64, arg1: i64) -> i64;

62

    fn i64_ctz(&mut self, arg0: i64) -> i64;

63

    fn i64_sextend_u64(&mut self, arg0: Type, arg1: u64) -> i64;

64

    fn i64_sextend_imm64(&mut self, arg0: Type, arg1: Imm64) -> i64;

65

    fn u64_uextend_imm64(&mut self, arg0: Type, arg1: Imm64) -> u64;

66

    fn imm64_icmp(&mut self, arg0: Type, arg1: &IntCC, arg2: Imm64, arg3: Imm64) -> Imm64;

67

    fn u64_is_zero(&mut self, arg0: u64) -> bool;

68

    fn u64_is_odd(&mut self, arg0: u64) -> bool;

69

    fn u128_replicated_u64(&mut self, arg0: u128) -> Option<u64>;

70

    fn u64_replicated_u32(&mut self, arg0: u64) -> Option<u64>;

71

    fn u32_replicated_u16(&mut self, arg0: u64) -> Option<u64>;

72

    fn u16_replicated_u8(&mut self, arg0: u64) -> Option<u8>;

73

    fn ty_umin(&mut self, arg0: Type) -> u64;

74

    fn ty_umax(&mut self, arg0: Type) -> u64;

75

    fn ty_smin(&mut self, arg0: Type) -> u64;

76

    fn ty_smax(&mut self, arg0: Type) -> u64;

77

    fn ty_bits(&mut self, arg0: Type) -> u8;

78

    fn ty_bits_u16(&mut self, arg0: Type) -> u16;

79

    fn ty_bits_u64(&mut self, arg0: Type) -> u64;

80

    fn ty_mask(&mut self, arg0: Type) -> u64;

81

    fn ty_lane_mask(&mut self, arg0: Type) -> u64;

82

    fn ty_lane_count(&mut self, arg0: Type) -> u64;

83

    fn ty_bytes(&mut self, arg0: Type) -> u16;

84

    fn lane_type(&mut self, arg0: Type) -> Type;

85

    fn ty_half_lanes(&mut self, arg0: Type) -> Option<Type>;

86

    fn ty_half_width(&mut self, arg0: Type) -> Option<Type>;

87

    fn ty_equal(&mut self, arg0: Type, arg1: Type) -> bool;

88

    fn mem_flags_trusted(&mut self) -> MemFlags;

89

    fn intcc_swap_args(&mut self, arg0: &IntCC) -> IntCC;

90

    fn intcc_complement(&mut self, arg0: &IntCC) -> IntCC;

91

    fn intcc_without_eq(&mut self, arg0: &IntCC) -> IntCC;

92

    fn floatcc_swap_args(&mut self, arg0: &FloatCC) -> FloatCC;

93

    fn floatcc_complement(&mut self, arg0: &FloatCC) -> FloatCC;

94

    fn floatcc_unordered(&mut self, arg0: &FloatCC) -> bool;

95

    fn fits_in_16(&mut self, arg0: Type) -> Option<Type>;

96

    fn fits_in_32(&mut self, arg0: Type) -> Option<Type>;

97

    fn lane_fits_in_32(&mut self, arg0: Type) -> Option<Type>;

98

    fn fits_in_64(&mut self, arg0: Type) -> Option<Type>;

99

    fn ty_32(&mut self, arg0: Type) -> Option<Type>;

100

    fn ty_64(&mut self, arg0: Type) -> Option<Type>;

101

    fn ty_int_ref_scalar_64_extract(&mut self, arg0: Type) -> Option<Type>;

102

    fn ty_int_ref_scalar_64(&mut self, arg0: Type) -> Option<Type>;

103

    fn ty_32_or_64(&mut self, arg0: Type) -> Option<Type>;

104

    fn ty_8_or_16(&mut self, arg0: Type) -> Option<Type>;

105

    fn int_fits_in_32(&mut self, arg0: Type) -> Option<Type>;

106

    fn ty_int_ref_64(&mut self, arg0: Type) -> Option<Type>;

107

    fn ty_int_ref_16_to_64(&mut self, arg0: Type) -> Option<Type>;

108

    fn ty_int(&mut self, arg0: Type) -> Option<Type>;

109

    fn ty_scalar(&mut self, arg0: Type) -> Option<Type>;

110

    fn ty_scalar_float(&mut self, arg0: Type) -> Option<Type>;

111

    fn ty_float_or_vec(&mut self, arg0: Type) -> Option<Type>;

112

    fn ty_vector_float(&mut self, arg0: Type) -> Option<Type>;

113

    fn ty_vector_not_float(&mut self, arg0: Type) -> Option<Type>;

114

    fn ty_vec64(&mut self, arg0: Type) -> Option<Type>;

115

    fn ty_vec64_ctor(&mut self, arg0: Type) -> Option<Type>;

116

    fn ty_vec128(&mut self, arg0: Type) -> Option<Type>;

117

    fn ty_dyn_vec64(&mut self, arg0: Type) -> Option<Type>;

118

    fn ty_dyn_vec128(&mut self, arg0: Type) -> Option<Type>;

119

    fn ty_vec64_int(&mut self, arg0: Type) -> Option<Type>;

120

    fn ty_vec128_int(&mut self, arg0: Type) -> Option<Type>;

121

    fn ty_addr64(&mut self, arg0: Type) -> Option<Type>;

122

    fn not_vec32x2(&mut self, arg0: Type) -> Option<Type>;

123

    fn not_i64x2(&mut self, arg0: Type) -> Option<()>;

124

    fn u8_from_uimm8(&mut self, arg0: Uimm8) -> u8;

125

    fn u64_from_bool(&mut self, arg0: bool) -> u64;

126

    fn u64_from_imm64(&mut self, arg0: Imm64) -> u64;

127

    fn nonzero_u64_from_imm64(&mut self, arg0: Imm64) -> Option<u64>;

128

    fn imm64_power_of_two(&mut self, arg0: Imm64) -> Option<u64>;

129

    fn imm64(&mut self, arg0: u64) -> Imm64;

130

    fn imm64_masked(&mut self, arg0: Type, arg1: u64) -> Imm64;

131

    fn u32_from_ieee32(&mut self, arg0: Ieee32) -> u32;

132

    fn u64_from_ieee64(&mut self, arg0: Ieee64) -> u64;

133

    fn multi_lane(&mut self, arg0: Type) -> Option<(u32, u32)>;

134

    fn dynamic_lane(&mut self, arg0: Type) -> Option<(u32, u32)>;

135

    fn dynamic_int_lane(&mut self, arg0: Type) -> Option<u32>;

136

    fn dynamic_fp_lane(&mut self, arg0: Type) -> Option<u32>;

137

    fn ty_dyn64_int(&mut self, arg0: Type) -> Option<Type>;

138

    fn ty_dyn128_int(&mut self, arg0: Type) -> Option<Type>;

139

    fn offset32_to_i32(&mut self, arg0: Offset32) -> i32;

140

    fn i32_to_offset32(&mut self, arg0: i32) -> Offset32;

141

    fn intcc_unsigned(&mut self, arg0: &IntCC) -> IntCC;

142

    fn signed_cond_code(&mut self, arg0: &IntCC) -> Option<IntCC>;

143

    fn trap_code_division_by_zero(&mut self) -> TrapCode;

144

    fn trap_code_integer_overflow(&mut self) -> TrapCode;

145

    fn trap_code_bad_conversion_to_integer(&mut self) -> TrapCode;

146

    fn range(&mut self, arg0: usize, arg1: usize) -> Range;

147

    fn range_view(&mut self, arg0: Range) -> RangeView;

148

    fn value_reg(&mut self, arg0: Reg) -> ValueRegs;

149

    fn writable_value_reg(&mut self, arg0: WritableReg) -> WritableValueRegs;

150

    fn value_regs(&mut self, arg0: Reg, arg1: Reg) -> ValueRegs;

151

    fn writable_value_regs(&mut self, arg0: WritableReg, arg1: WritableReg) -> WritableValueRegs;

152

    fn value_regs_invalid(&mut self) -> ValueRegs;

153

    fn output_none(&mut self) -> InstOutput;

154

    fn output(&mut self, arg0: ValueRegs) -> InstOutput;

155

    fn output_pair(&mut self, arg0: ValueRegs, arg1: ValueRegs) -> InstOutput;

156

    fn output_builder_new(&mut self) -> InstOutputBuilder;

157

    fn output_builder_push(&mut self, arg0: &InstOutputBuilder, arg1: ValueRegs) -> Unit;

158

    fn output_builder_finish(&mut self, arg0: &InstOutputBuilder) -> InstOutput;

159

    fn temp_writable_reg(&mut self, arg0: Type) -> WritableReg;

160

    fn is_valid_reg(&mut self, arg0: Reg) -> bool;

161

    fn invalid_reg(&mut self) -> Reg;

162

    fn mark_value_used(&mut self, arg0: Value) -> Unit;

163

    fn put_in_reg(&mut self, arg0: Value) -> Reg;

164

    fn put_in_regs(&mut self, arg0: Value) -> ValueRegs;

165

    fn ensure_in_vreg(&mut self, arg0: Reg, arg1: Type) -> Reg;

166

    fn value_regs_get(&mut self, arg0: ValueRegs, arg1: usize) -> Reg;

167

    fn value_regs_len(&mut self, arg0: ValueRegs) -> usize;

168

    fn preg_to_reg(&mut self, arg0: PReg) -> Reg;

169

    fn single_target(&mut self, arg0: &MachLabelSlice) -> Option<MachLabel>;

170

    fn two_targets(&mut self, arg0: &MachLabelSlice) -> Option<(MachLabel, MachLabel)>;

171

    fn jump_table_targets(&mut self, arg0: &MachLabelSlice)

172

        -> Option<(MachLabel, BoxVecMachLabel)>;

173

    fn jump_table_size(&mut self, arg0: &BoxVecMachLabel) -> u32;

174

    fn value_list_slice(&mut self, arg0: ValueList) -> ValueSlice;

175

    fn value_slice_empty(&mut self, arg0: ValueSlice) -> Option<()>;

176

    fn value_slice_unwrap(&mut self, arg0: ValueSlice) -> Option<(Value, ValueSlice)>;

177

    fn value_slice_len(&mut self, arg0: ValueSlice) -> usize;

178

    fn value_slice_get(&mut self, arg0: ValueSlice, arg1: usize) -> Value;

179

    fn writable_reg_to_reg(&mut self, arg0: WritableReg) -> Reg;

180

    fn inst_results(&mut self, arg0: Inst) -> ValueSlice;

181

    fn first_result(&mut self, arg0: Inst) -> Option<Value>;

182

    fn inst_data(&mut self, arg0: Inst) -> InstructionData;

183

    fn def_inst(&mut self, arg0: Value) -> Option<Inst>;

184

    fn i64_from_iconst(&mut self, arg0: Value) -> Option<i64>;

185

    fn zero_value(&mut self, arg0: Value) -> Option<Value>;

186

    fn is_sinkable_inst(&mut self, arg0: Value) -> Option<Inst>;

187

    fn maybe_uextend(&mut self, arg0: Value) -> Option<Value>;

188

    fn emit(&mut self, arg0: &MInst) -> Unit;

189

    fn sink_inst(&mut self, arg0: Inst) -> Unit;

190

    fn emit_u64_le_const(&mut self, arg0: u64) -> VCodeConstant;

191

    fn emit_u128_le_const(&mut self, arg0: u128) -> VCodeConstant;

192

    fn const_to_vconst(&mut self, arg0: Constant) -> VCodeConstant;

193

    fn tls_model(&mut self, arg0: Type) -> TlsModel;

194

    fn tls_model_is_elf_gd(&mut self) -> Option<Unit>;

195

    fn tls_model_is_macho(&mut self) -> Option<Unit>;

196

    fn tls_model_is_coff(&mut self) -> Option<Unit>;

197

    fn preserve_frame_pointers(&mut self) -> Option<Unit>;

198

    fn box_external_name(&mut self, arg0: ExternalName) -> BoxExternalName;

199

    fn func_ref_data(&mut self, arg0: FuncRef) -> (SigRef, ExternalName, RelocDistance);

200

    fn symbol_value_data(

201

        &mut self,

202

        arg0: GlobalValue,

203

    ) -> Option<(ExternalName, RelocDistance, i64)>;

204

    fn reloc_distance_near(&mut self, arg0: RelocDistance) -> Option<()>;

205

    fn vec_mask_from_immediate(&mut self, arg0: Immediate) -> Option<VecMask>;

206

    fn u128_from_immediate(&mut self, arg0: Immediate) -> Option<u128>;

207

    fn vconst_from_immediate(&mut self, arg0: Immediate) -> Option<VCodeConstant>;

208

    fn u128_from_constant(&mut self, arg0: Constant) -> Option<u128>;

209

    fn u64_from_constant(&mut self, arg0: Constant) -> Option<u64>;

210

    fn shuffle64_from_imm(&mut self, arg0: Immediate) -> Option<(u8, u8)>;

211

    fn shuffle32_from_imm(&mut self, arg0: Immediate) -> Option<(u8, u8, u8, u8)>;

212

    fn shuffle16_from_imm(&mut self, arg0: Immediate) -> Option<(u8, u8, u8, u8, u8, u8, u8, u8)>;

213

    fn only_writable_reg(&mut self, arg0: WritableValueRegs) -> Option<WritableReg>;

214

    fn writable_regs_get(&mut self, arg0: WritableValueRegs, arg1: usize) -> WritableReg;

215

    fn abi_num_args(&mut self, arg0: Sig) -> usize;

216

    fn abi_get_arg(&mut self, arg0: Sig, arg1: usize) -> ABIArg;

217

    fn abi_num_rets(&mut self, arg0: Sig) -> usize;

218

    fn abi_get_ret(&mut self, arg0: Sig, arg1: usize) -> ABIArg;

219

    fn abi_ret_arg(&mut self, arg0: Sig) -> Option<ABIArg>;

220

    fn abi_no_ret_arg(&mut self, arg0: Sig) -> Option<()>;

221

    fn abi_sized_stack_arg_space(&mut self, arg0: Sig) -> i64;

222

    fn abi_sized_stack_ret_space(&mut self, arg0: Sig) -> i64;

223

    fn abi_stackslot_addr(&mut self, arg0: WritableReg, arg1: StackSlot, arg2: Offset32) -> MInst;

224

    fn abi_dynamic_stackslot_addr(&mut self, arg0: WritableReg, arg1: DynamicStackSlot) -> MInst;

225

    fn abi_arg_only_slot(&mut self, arg0: &ABIArg) -> Option<ABIArgSlot>;

226

    fn abi_arg_struct_pointer(&mut self, arg0: &ABIArg) -> Option<(ABIArgSlot, i64, u64)>;

227

    fn abi_arg_implicit_pointer(&mut self, arg0: &ABIArg) -> Option<(ABIArgSlot, i64, Type)>;

228

    fn real_reg_to_reg(&mut self, arg0: RealReg) -> Reg;

229

    fn real_reg_to_writable_reg(&mut self, arg0: RealReg) -> WritableReg;

230

    fn gen_move(&mut self, arg0: Type, arg1: WritableReg, arg2: Reg) -> MInst;

231

    fn gen_return(&mut self, arg0: ValueSlice) -> Unit;

232

    fn gen_return_call(

233

        &mut self,

234

        arg0: SigRef,

235

        arg1: ExternalName,

236

        arg2: RelocDistance,

237

        arg3: ValueSlice,

238

    ) -> InstOutput;

239

    fn gen_return_call_indirect(

240

        &mut self,

241

        arg0: SigRef,

242

        arg1: Value,

243

        arg2: ValueSlice,

244

    ) -> InstOutput;

245

    fn safe_divisor_from_imm64(&mut self, arg0: Type, arg1: Imm64) -> Option<u64>;

246

    fn operand_size_of_type_32_64(&mut self, arg0: Type) -> OperandSize;

247

    fn raw_operand_size_of_type(&mut self, arg0: Type) -> OperandSize;

248

    fn put_in_reg_mem_imm(&mut self, arg0: Value) -> RegMemImm;

249

    fn put_in_reg_mem(&mut self, arg0: Value) -> RegMem;

250

    fn synthetic_amode_to_reg_mem(&mut self, arg0: &SyntheticAmode) -> RegMem;

251

    fn amode_to_synthetic_amode(&mut self, arg0: &Amode) -> SyntheticAmode;

252

    fn sum_extend_fits_in_32_bits(

253

        &mut self,

254

        arg0: Type,

255

        arg1: Imm64,

256

        arg2: Offset32,

257

    ) -> Option<u32>;

258

    fn amode_offset(&mut self, arg0: &Amode, arg1: i32) -> Amode;

259

    fn zero_offset(&mut self) -> Offset32;

260

    fn intcc_to_cc(&mut self, arg0: &IntCC) -> CC;

261

    fn cc_invert(&mut self, arg0: &CC) -> CC;

262

    fn cc_nz_or_z(&mut self, arg0: &CC) -> Option<CC>;

263

    fn encode_fcmp_imm(&mut self, arg0: &FcmpImm) -> u8;

264

    fn encode_round_imm(&mut self, arg0: &RoundImm) -> u8;

265

    fn imm8_reg_to_imm8_gpr(&mut self, arg0: &Imm8Reg) -> Imm8Gpr;

266

    fn gpr_from_imm8_gpr(&mut self, arg0: &Imm8Gpr) -> Option<Gpr>;

267

    fn imm8_from_imm8_gpr(&mut self, arg0: &Imm8Gpr) -> Option<u8>;

268

    fn writable_gpr_to_reg(&mut self, arg0: WritableGpr) -> WritableReg;

269

    fn writable_xmm_to_reg(&mut self, arg0: WritableXmm) -> WritableReg;

270

    fn writable_reg_to_xmm(&mut self, arg0: WritableReg) -> WritableXmm;

271

    fn writable_xmm_to_xmm(&mut self, arg0: WritableXmm) -> Xmm;

272

    fn writable_gpr_to_gpr(&mut self, arg0: WritableGpr) -> Gpr;

273

    fn gpr_to_reg(&mut self, arg0: Gpr) -> Reg;

274

    fn gpr_to_gpr_mem(&mut self, arg0: Gpr) -> GprMem;

275

    fn gpr_to_gpr_mem_imm(&mut self, arg0: Gpr) -> GprMemImm;

276

    fn xmm_to_reg(&mut self, arg0: Xmm) -> Reg;

277

    fn xmm_to_xmm_mem_imm(&mut self, arg0: Xmm) -> XmmMemImm;

278

    fn xmm_mem_to_xmm_mem_imm(&mut self, arg0: &XmmMem) -> XmmMemImm;

279

    fn xmm_mem_to_xmm_mem_aligned(&mut self, arg0: &XmmMem) -> XmmMemAligned;

280

    fn xmm_mem_imm_to_xmm_mem_aligned_imm(&mut self, arg0: &XmmMemImm) -> XmmMemAlignedImm;

281

    fn temp_writable_gpr(&mut self) -> WritableGpr;

282

    fn temp_writable_xmm(&mut self) -> WritableXmm;

283

    fn reg_mem_to_xmm_mem(&mut self, arg0: &RegMem) -> XmmMem;

284

    fn reg_to_reg_mem_imm(&mut self, arg0: Reg) -> RegMemImm;

285

    fn gpr_mem_imm_new(&mut self, arg0: &RegMemImm) -> GprMemImm;

286

    fn xmm_mem_imm_new(&mut self, arg0: &RegMemImm) -> XmmMemImm;

287

    fn xmm_to_xmm_mem(&mut self, arg0: Xmm) -> XmmMem;

288

    fn xmm_mem_to_reg_mem(&mut self, arg0: &XmmMem) -> RegMem;

289

    fn gpr_mem_to_reg_mem(&mut self, arg0: &GprMem) -> RegMem;

290

    fn xmm_new(&mut self, arg0: Reg) -> Xmm;

291

    fn gpr_new(&mut self, arg0: Reg) -> Gpr;

292

    fn reg_mem_to_gpr_mem(&mut self, arg0: &RegMem) -> GprMem;

293

    fn reg_to_gpr_mem(&mut self, arg0: Reg) -> GprMem;

294

    fn put_in_xmm_mem(&mut self, arg0: Value) -> XmmMem;

295

    fn put_in_xmm_mem_imm(&mut self, arg0: Value) -> XmmMemImm;

296

    fn gpr_to_imm8_gpr(&mut self, arg0: Gpr) -> Imm8Gpr;

297

    fn imm8_to_imm8_gpr(&mut self, arg0: u8) -> Imm8Gpr;

298

    fn xmi_imm(&mut self, arg0: u32) -> XmmMemImm;

299

    fn type_register_class(&mut self, arg0: Type) -> Option<RegisterClass>;

300

    fn use_avx512vl(&mut self) -> bool;

301

    fn use_avx512dq(&mut self) -> bool;

302

    fn use_avx512f(&mut self) -> bool;

303

    fn use_avx512bitalg(&mut self) -> bool;

304

    fn use_avx512vbmi(&mut self) -> bool;

305

    fn use_lzcnt(&mut self) -> bool;

306

    fn use_bmi1(&mut self) -> bool;

307

    fn use_bmi2(&mut self) -> bool;

308

    fn use_popcnt(&mut self) -> bool;

309

    fn use_fma(&mut self) -> bool;

310

    fn use_ssse3(&mut self) -> bool;

311

    fn use_sse41(&mut self) -> bool;

312

    fn use_sse42(&mut self) -> bool;

313

    fn use_avx(&mut self) -> bool;

314

    fn use_avx2(&mut self) -> bool;

315

    fn imm8_from_value(&mut self, arg0: Value) -> Option<Imm8Reg>;

316

    fn const_to_type_masked_imm8(&mut self, arg0: u64, arg1: Type) -> Imm8Gpr;

317

    fn shift_mask(&mut self, arg0: Type) -> u8;

318

    fn shift_amount_masked(&mut self, arg0: Type, arg1: Imm64) -> u8;

319

    fn simm32_from_value(&mut self, arg0: Value) -> Option<GprMemImm>;

320

    fn simm32_from_imm64(&mut self, arg0: Imm64) -> Option<GprMemImm>;

321

    fn sinkable_load(&mut self, arg0: Value) -> Option<SinkableLoad>;

322

    fn sinkable_load_exact(&mut self, arg0: Value) -> Option<SinkableLoad>;

323

    fn sink_load(&mut self, arg0: &SinkableLoad) -> SyntheticAmode;

324

    fn ext_mode(&mut self, arg0: u16, arg1: u16) -> ExtMode;

325

    fn gen_call(

326

        &mut self,

327

        arg0: SigRef,

328

        arg1: ExternalName,

329

        arg2: RelocDistance,

330

        arg3: ValueSlice,

331

    ) -> InstOutput;

332

    fn gen_call_indirect(&mut self, arg0: SigRef, arg1: Value, arg2: ValueSlice) -> InstOutput;

333

    fn nonzero_u64_fits_in_u32(&mut self, arg0: u64) -> Option<u64>;

334

    fn ty_int_bool_or_ref(&mut self, arg0: Type) -> Option<()>;

335

    fn atomic_rmw_op_to_mach_atomic_rmw_op(&mut self, arg0: &AtomicRmwOp) -> MachAtomicRmwOp;

336

    fn shuffle_0_31_mask(&mut self, arg0: &VecMask) -> VCodeConstant;

337

    fn shuffle_0_15_mask(&mut self, arg0: &VecMask) -> VCodeConstant;

338

    fn shuffle_16_31_mask(&mut self, arg0: &VecMask) -> VCodeConstant;

339

    fn perm_from_mask(&mut self, arg0: &VecMask) -> VCodeConstant;

340

    fn perm_from_mask_with_zeros(

341

        &mut self,

342

        arg0: &VecMask,

343

    ) -> Option<(VCodeConstant, VCodeConstant)>;

344

    fn const_to_synthetic_amode(&mut self, arg0: VCodeConstant) -> SyntheticAmode;

345

    fn preg_rbp(&mut self) -> PReg;

346

    fn preg_rsp(&mut self) -> PReg;

347

    fn preg_pinned(&mut self) -> PReg;

348

    fn libcall_1(&mut self, arg0: &LibCall, arg1: Reg) -> Reg;

349

    fn libcall_2(&mut self, arg0: &LibCall, arg1: Reg, arg2: Reg) -> Reg;

350

    fn libcall_3(&mut self, arg0: &LibCall, arg1: Reg, arg2: Reg, arg3: Reg) -> Reg;

351

    fn ishl_i8x16_mask_for_const(&mut self, arg0: u32) -> SyntheticAmode;

352

    fn ishl_i8x16_mask_table(&mut self) -> SyntheticAmode;

353

    fn ushr_i8x16_mask_for_const(&mut self, arg0: u32) -> SyntheticAmode;

354

    fn ushr_i8x16_mask_table(&mut self) -> SyntheticAmode;

355

    fn vconst_all_ones_or_all_zeros(&mut self, arg0: Constant) -> Option<()>;

356

    fn insert_i8x16_lane_hole(&mut self, arg0: u8) -> VCodeConstant;

357

    fn sse_insertps_lane_imm(&mut self, arg0: u8) -> u8;

358

    fn pblendw_imm(&mut self, arg0: Immediate) -> Option<u8>;

359

    fn palignr_imm_from_immediate(&mut self, arg0: Immediate) -> Option<u8>;

360

    fn pshuflw_lhs_imm(&mut self, arg0: Immediate) -> Option<u8>;

361

    fn pshuflw_rhs_imm(&mut self, arg0: Immediate) -> Option<u8>;

362

    fn pshufhw_lhs_imm(&mut self, arg0: Immediate) -> Option<u8>;

363

    fn pshufhw_rhs_imm(&mut self, arg0: Immediate) -> Option<u8>;

364

    fn pshufd_lhs_imm(&mut self, arg0: Immediate) -> Option<u8>;

365

    fn pshufd_rhs_imm(&mut self, arg0: Immediate) -> Option<u8>;

366

    fn shufps_imm(&mut self, arg0: Immediate) -> Option<u8>;

367

    fn shufps_rev_imm(&mut self, arg0: Immediate) -> Option<u8>;

368

    fn unpack_value_array_2(&mut self, arg0: &ValueArray2) -> (Value, Value);

369

    fn pack_value_array_2(&mut self, arg0: Value, arg1: Value) -> ValueArray2;

370

    fn unpack_value_array_3(&mut self, arg0: &ValueArray3) -> (Value, Value, Value);

371

    fn pack_value_array_3(&mut self, arg0: Value, arg1: Value, arg2: Value) -> ValueArray3;

372

    fn unpack_block_array_2(&mut self, arg0: &BlockArray2) -> (BlockCall, BlockCall);

373

    fn pack_block_array_2(&mut self, arg0: BlockCall, arg1: BlockCall) -> BlockArray2;

374

375

376

pub trait ContextIter {

377

    type Context;

378

    type Output;

379

    fn next(&mut self, ctx: &mut Self::Context) -> Option<Self::Output>;

380

381

382

pub struct ContextIterWrapper<Item, I: Iterator<Item = Item>, C: Context> {

383

    iter: I,

384

    _ctx: PhantomData<C>,

385

386

impl<Item, I: Iterator<Item = Item>, C: Context> From<I> for ContextIterWrapper<Item, I, C> {

387

    fn from(iter: I) -> Self {

388

        Self {

389

            iter,

390

            _ctx: PhantomData,

391

392

393

394

impl<Item, I: Iterator<Item = Item>, C: Context> ContextIter for ContextIterWrapper<Item, I, C> {

395

    type Context = C;

396

    type Output = Item;

397

    fn next(&mut self, _ctx: &mut Self::Context) -> Option<Self::Output> {

398

        self.iter.next()

399

400

401

402

/// Internal type MultiReg: defined at src/prelude_lower.isle line 21.

403

#[derive(Clone, Debug)]

404

pub enum MultiReg {

405

    Empty,

406

    One { a: Reg },

407

    Two { a: Reg, b: Reg },

408

    Three { a: Reg, b: Reg, c: Reg },

409

    Four { a: Reg, b: Reg, c: Reg, d: Reg },

410

411

412

/// Internal type SideEffectNoResult: defined at src/prelude_lower.isle line 340.

413

#[derive(Clone, Debug)]

414

pub enum SideEffectNoResult {

415

    Inst {

416

        inst: MInst,

417

},

418

    Inst2 {

419

        inst1: MInst,

420

        inst2: MInst,

421

},

422

    Inst3 {

423

        inst1: MInst,

424

        inst2: MInst,

425

        inst3: MInst,

426

},

427

428

429

/// Internal type ProducesFlags: defined at src/prelude_lower.isle line 382.

430

#[derive(Clone, Debug)]

431

pub enum ProducesFlags {

432

    AlreadyExistingFlags,

433

    ProducesFlagsSideEffect { inst: MInst },

434

    ProducesFlagsTwiceSideEffect { inst1: MInst, inst2: MInst },

435

    ProducesFlagsReturnsReg { inst: MInst, result: Reg },

436

    ProducesFlagsReturnsResultWithConsumer { inst: MInst, result: Reg },

437

438

439

/// Internal type ConsumesAndProducesFlags: defined at src/prelude_lower.isle line 401.

440

#[derive(Clone, Debug)]

441

pub enum ConsumesAndProducesFlags {

442

    SideEffect { inst: MInst },

443

    ReturnsReg { inst: MInst, result: Reg },

444

445

446

/// Internal type ConsumesFlags: defined at src/prelude_lower.isle line 409.

447

#[derive(Clone, Debug)]

448

pub enum ConsumesFlags {

449

    ConsumesFlagsSideEffect {

450

        inst: MInst,

451

},

452

    ConsumesFlagsSideEffect2 {

453

        inst1: MInst,

454

        inst2: MInst,

455

},

456

    ConsumesFlagsReturnsResultWithProducer {

457

        inst: MInst,

458

        result: Reg,

459

},

460

    ConsumesFlagsReturnsReg {

461

        inst: MInst,

462

        result: Reg,

463

},

464

    ConsumesFlagsTwiceReturnsValueRegs {

465

        inst1: MInst,

466

        inst2: MInst,

467

        result: ValueRegs,

468

},

469

    ConsumesFlagsFourTimesReturnsValueRegs {

470

        inst1: MInst,

471

        inst2: MInst,

472

        inst3: MInst,

473

        inst4: MInst,

474

        result: ValueRegs,

475

},

476

477

478

/// Internal type MInst: defined at src/isa/x64/inst.isle line 8.

479

#[derive(Clone)]

480

pub enum MInst {

481

    Nop {

482

        len: u8,

483

},

484

    AluRmiR {

485

        size: OperandSize,

486

        op: AluRmiROpcode,

487

        src1: Gpr,

488

        src2: GprMemImm,

489

        dst: WritableGpr,

490

},

491

    AluRM {

492

        size: OperandSize,

493

        op: AluRmiROpcode,

494

        src1_dst: SyntheticAmode,

495

        src2: Gpr,

496

},

497

    AluRmRVex {

498

        size: OperandSize,

499

        op: AluRmROpcode,

500

        src1: Gpr,

501

        src2: GprMem,

502

        dst: WritableGpr,

503

},

504

    AluConstOp {

505

        op: AluRmiROpcode,

506

        size: OperandSize,

507

        dst: WritableGpr,

508

},

509

    UnaryRmR {

510

        size: OperandSize,

511

        op: UnaryRmROpcode,

512

        src: GprMem,

513

        dst: WritableGpr,

514

},

515

    UnaryRmRVex {

516

        size: OperandSize,

517

        op: UnaryRmRVexOpcode,

518

        src: GprMem,

519

        dst: WritableGpr,

520

},

521

    UnaryRmRImmVex {

522

        size: OperandSize,

523

        op: UnaryRmRImmVexOpcode,

524

        src: GprMem,

525

        dst: WritableGpr,

526

        imm: u8,

527

},

528

    Not {

529

        size: OperandSize,

530

        src: Gpr,

531

        dst: WritableGpr,

532

},

533

    Neg {

534

        size: OperandSize,

535

        src: Gpr,

536

        dst: WritableGpr,

537

},

538

    Div {

539

        size: OperandSize,

540

        sign: DivSignedness,

541

        trap: TrapCode,

542

        divisor: GprMem,

543

        dividend_lo: Gpr,

544

        dividend_hi: Gpr,

545

        dst_quotient: WritableGpr,

546

        dst_remainder: WritableGpr,

547

},

548

    Div8 {

549

        sign: DivSignedness,

550

        trap: TrapCode,

551

        divisor: GprMem,

552

        dividend: Gpr,

553

        dst: WritableGpr,

554

},

555

    MulHi {

556

        size: OperandSize,

557

        signed: bool,

558

        src1: Gpr,

559

        src2: GprMem,

560

        dst_lo: WritableGpr,

561

        dst_hi: WritableGpr,

562

},

563

    UMulLo {

564

        size: OperandSize,

565

        src1: Gpr,

566

        src2: GprMem,

567

        dst: WritableGpr,

568

},

569

    CheckedSRemSeq {

570

        size: OperandSize,

571

        dividend_lo: Gpr,

572

        dividend_hi: Gpr,

573

        divisor: Gpr,

574

        dst_quotient: WritableGpr,

575

        dst_remainder: WritableGpr,

576

},

577

    CheckedSRemSeq8 {

578

        dividend: Gpr,

579

        divisor: Gpr,

580

        dst: WritableGpr,

581

},

582

    SignExtendData {

583

        size: OperandSize,

584

        src: Gpr,

585

        dst: WritableGpr,

586

},

587

    Imm {

588

        dst_size: OperandSize,

589

        simm64: u64,

590

        dst: WritableGpr,

591

},

592

    MovRR {

593

        size: OperandSize,

594

        src: Gpr,

595

        dst: WritableGpr,

596

},

597

    MovFromPReg {

598

        src: PReg,

599

        dst: WritableGpr,

600

},

601

    MovToPReg {

602

        src: Gpr,

603

        dst: PReg,

604

},

605

    MovzxRmR {

606

        ext_mode: ExtMode,

607

        src: GprMem,

608

        dst: WritableGpr,

609

},

610

    Mov64MR {

611

        src: SyntheticAmode,

612

        dst: WritableGpr,

613

},

614

    LoadEffectiveAddress {

615

        addr: SyntheticAmode,

616

        dst: WritableGpr,

617

        size: OperandSize,

618

},

619

    MovsxRmR {

620

        ext_mode: ExtMode,

621

        src: GprMem,

622

        dst: WritableGpr,

623

},

624

    MovImmM {

625

        size: OperandSize,

626

        simm32: i32,

627

        dst: SyntheticAmode,

628

},

629

    MovRM {

630

        size: OperandSize,

631

        src: Gpr,

632

        dst: SyntheticAmode,

633

},

634

    ShiftR {

635

        size: OperandSize,

636

        kind: ShiftKind,

637

        src: Gpr,

638

        num_bits: Imm8Gpr,

639

        dst: WritableGpr,

640

},

641

    XmmRmiReg {

642

        opcode: SseOpcode,

643

        src1: Xmm,

644

        src2: XmmMemAlignedImm,

645

        dst: WritableXmm,

646

},

647

    CmpRmiR {

648

        size: OperandSize,

649

        opcode: CmpOpcode,

650

        src: GprMemImm,

651

        dst: Gpr,

652

},

653

    Setcc {

654

        cc: CC,

655

        dst: WritableGpr,

656

},

657

    Bswap {

658

        size: OperandSize,

659

        src: Gpr,

660

        dst: WritableGpr,

661

},

662

    Cmove {

663

        size: OperandSize,

664

        cc: CC,

665

        consequent: GprMem,

666

        alternative: Gpr,

667

        dst: WritableGpr,

668

},

669

    XmmCmove {

670

        ty: Type,

671

        cc: CC,

672

        consequent: XmmMemAligned,

673

        alternative: Xmm,

674

        dst: WritableXmm,

675

},

676

    Push64 {

677

        src: GprMemImm,

678

},

679

    Pop64 {

680

        dst: WritableGpr,

681

},

682

    StackProbeLoop {

683

        tmp: WritableReg,

684

        frame_size: u32,

685

        guard_size: u32,

686

},

687

    XmmRmR {

688

        op: SseOpcode,

689

        src1: Xmm,

690

        src2: XmmMemAligned,

691

        dst: WritableXmm,

692

},

693

    XmmRmRUnaligned {

694

        op: SseOpcode,

695

        src1: Xmm,

696

        src2: XmmMem,

697

        dst: WritableXmm,

698

},

699

    XmmRmRBlend {

700

        op: SseOpcode,

701

        src1: Xmm,

702

        src2: XmmMemAligned,

703

        mask: Xmm,

704

        dst: WritableXmm,

705

},

706

    XmmRmiRVex {

707

        op: AvxOpcode,

708

        src1: Xmm,

709

        src2: XmmMemImm,

710

        dst: WritableXmm,

711

},

712

    XmmRmRImmVex {

713

        op: AvxOpcode,

714

        src1: Xmm,

715

        src2: XmmMem,

716

        dst: WritableXmm,

717

        imm: u8,

718

},

719

    XmmVexPinsr {

720

        op: AvxOpcode,

721

        src1: Xmm,

722

        src2: GprMem,

723

        dst: WritableXmm,

724

        imm: u8,

725

},

726

    XmmRmRVex3 {

727

        op: AvxOpcode,

728

        src1: Xmm,

729

        src2: Xmm,

730

        src3: XmmMem,

731

        dst: WritableXmm,

732

},

733

    XmmRmRBlendVex {

734

        op: AvxOpcode,

735

        src1: Xmm,

736

        src2: XmmMem,

737

        mask: Xmm,

738

        dst: WritableXmm,

739

},

740

    XmmUnaryRmRVex {

741

        op: AvxOpcode,

742

        src: XmmMem,

743

        dst: WritableXmm,

744

},

745

    XmmUnaryRmRImmVex {

746

        op: AvxOpcode,

747

        src: XmmMem,

748

        dst: WritableXmm,

749

        imm: u8,

750

},

751

    XmmMovRMVex {

752

        op: AvxOpcode,

753

        src: Xmm,

754

        dst: SyntheticAmode,

755

},

756

    XmmMovRMImmVex {

757

        op: AvxOpcode,

758

        src: Xmm,

759

        dst: SyntheticAmode,

760

        imm: u8,

761

},

762

    XmmToGprImmVex {

763

        op: AvxOpcode,

764

        src: Xmm,

765

        dst: WritableGpr,

766

        imm: u8,

767

},

768

    GprToXmmVex {

769

        op: AvxOpcode,

770

        src: GprMem,

771

        dst: WritableXmm,

772

        src_size: OperandSize,

773

},

774

    XmmToGprVex {

775

        op: AvxOpcode,

776

        src: Xmm,

777

        dst: WritableGpr,

778

        dst_size: OperandSize,

779

},

780

    XmmRmREvex {

781

        op: Avx512Opcode,

782

        src1: Xmm,

783

        src2: XmmMem,

784

        dst: WritableXmm,

785

},

786

    XmmUnaryRmRImmEvex {

787

        op: Avx512Opcode,

788

        src: XmmMem,

789

        dst: WritableXmm,

790

        imm: u8,

791

},

792

    XmmRmREvex3 {

793

        op: Avx512Opcode,

794

        src1: Xmm,

795

        src2: Xmm,

796

        src3: XmmMem,

797

        dst: WritableXmm,

798

},

799

    XmmUnaryRmR {

800

        op: SseOpcode,

801

        src: XmmMemAligned,

802

        dst: WritableXmm,

803

},

804

    XmmUnaryRmRUnaligned {

805

        op: SseOpcode,

806

        src: XmmMem,

807

        dst: WritableXmm,

808

},

809

    XmmUnaryRmRImm {

810

        op: SseOpcode,

811

        src: XmmMemAligned,

812

        imm: u8,

813

        dst: WritableXmm,

814

},

815

    XmmUnaryRmREvex {

816

        op: Avx512Opcode,

817

        src: XmmMem,

818

        dst: WritableXmm,

819

},

820

    XmmMovRM {

821

        op: SseOpcode,

822

        src: Xmm,

823

        dst: SyntheticAmode,

824

},

825

    XmmMovRMImm {

826

        op: SseOpcode,

827

        src: Xmm,

828

        dst: SyntheticAmode,

829

        imm: u8,

830

},

831

    XmmToGpr {

832

        op: SseOpcode,

833

        src: Xmm,

834

        dst: WritableGpr,

835

        dst_size: OperandSize,

836

},

837

    XmmToGprImm {

838

        op: SseOpcode,

839

        src: Xmm,

840

        dst: WritableGpr,

841

        imm: u8,

842

},

843

    GprToXmm {

844

        op: SseOpcode,

845

        src: GprMem,

846

        dst: WritableXmm,

847

        src_size: OperandSize,

848

},

849

    CvtIntToFloat {

850

        op: SseOpcode,

851

        src1: Xmm,

852

        src2: GprMem,

853

        dst: WritableXmm,

854

        src2_size: OperandSize,

855

},

856

    CvtIntToFloatVex {

857

        op: AvxOpcode,

858

        src1: Xmm,

859

        src2: GprMem,

860

        dst: WritableXmm,

861

        src2_size: OperandSize,

862

},

863

    CvtUint64ToFloatSeq {

864

        dst_size: OperandSize,

865

        src: Gpr,

866

        dst: WritableXmm,

867

        tmp_gpr1: WritableGpr,

868

        tmp_gpr2: WritableGpr,

869

},

870

    CvtFloatToSintSeq {

871

        dst_size: OperandSize,

872

        src_size: OperandSize,

873

        is_saturating: bool,

874

        src: Xmm,

875

        dst: WritableGpr,

876

        tmp_gpr: WritableGpr,

877

        tmp_xmm: WritableXmm,

878

},

879

    CvtFloatToUintSeq {

880

        dst_size: OperandSize,

881

        src_size: OperandSize,

882

        is_saturating: bool,

883

        src: Xmm,

884

        dst: WritableGpr,

885

        tmp_gpr: WritableGpr,

886

        tmp_xmm: WritableXmm,

887

        tmp_xmm2: WritableXmm,

888

},

889

    XmmMinMaxSeq {

890

        size: OperandSize,

891

        is_min: bool,

892

        lhs: Xmm,

893

        rhs: Xmm,

894

        dst: WritableXmm,

895

},

896

    XmmCmpRmR {

897

        op: SseOpcode,

898

        src: XmmMemAligned,

899

        dst: Xmm,

900

},

901

    XmmRmRImm {

902

        op: SseOpcode,

903

        src1: Reg,

904

        src2: RegMem,

905

        dst: WritableReg,

906

        imm: u8,

907

        size: OperandSize,

908

},

909

    CallKnown {

910

        dest: ExternalName,

911

        info: BoxCallInfo,

912

},

913

    CallUnknown {

914

        dest: RegMem,

915

        info: BoxCallInfo,

916

},

917

    ReturnCallKnown {

918

        callee: ExternalName,

919

        info: BoxReturnCallInfo,

920

},

921

    ReturnCallUnknown {

922

        callee: RegMem,

923

        info: BoxReturnCallInfo,

924

},

925

    Args {

926

        args: VecArgPair,

927

},

928

    Rets {

929

        rets: VecRetPair,

930

},

931

    Ret {

932

        stack_bytes_to_pop: u32,

933

},

934

    JmpKnown {

935

        dst: MachLabel,

936

},

937

    JmpIf {

938

        cc: CC,

939

        taken: MachLabel,

940

},

941

    JmpCond {

942

        cc: CC,

943

        taken: MachLabel,

944

        not_taken: MachLabel,

945

},

946

    JmpTableSeq {

947

        idx: Reg,

948

        tmp1: WritableReg,

949

        tmp2: WritableReg,

950

        default_target: MachLabel,

951

        targets: BoxVecMachLabel,

952

},

953

    JmpUnknown {

954

        target: RegMem,

955

},

956

    TrapIf {

957

        cc: CC,

958

        trap_code: TrapCode,

959

},

960

    TrapIfAnd {

961

        cc1: CC,

962

        cc2: CC,

963

        trap_code: TrapCode,

964

},

965

    TrapIfOr {

966

        cc1: CC,

967

        cc2: CC,

968

        trap_code: TrapCode,

969

},

970

    Hlt,

971

    Ud2 {

972

        trap_code: TrapCode,

973

},

974

    LoadExtName {

975

        dst: WritableReg,

976

        name: BoxExternalName,

977

        offset: i64,

978

        distance: RelocDistance,

979

},

980

    LockCmpxchg {

981

        ty: Type,

982

        replacement: Reg,

983

        expected: Reg,

984

        mem: SyntheticAmode,

985

        dst_old: WritableReg,

986

},

987

    AtomicRmwSeq {

988

        ty: Type,

989

        op: MachAtomicRmwOp,

990

        mem: SyntheticAmode,

991

        operand: Reg,

992

        temp: WritableReg,

993

        dst_old: WritableReg,

994

},

995

    Fence {

996

        kind: FenceKind,

997

},

998

    VirtualSPOffsetAdj {

999

        offset: i64,

1000

},

1001

    XmmUninitializedValue {

1002

        dst: WritableXmm,

1003

},

1004

    ElfTlsGetAddr {

1005

        symbol: ExternalName,

1006

        dst: WritableGpr,

1007

},

1008

    MachOTlsGetAddr {

1009

        symbol: ExternalName,

1010

        dst: WritableGpr,

1011

},

1012

    CoffTlsGetAddr {

1013

        symbol: ExternalName,

1014

        dst: WritableGpr,

1015

        tmp: WritableGpr,

1016

},

1017

    Unwind {

1018

        inst: UnwindInst,

1019

},

1020

    DummyUse {

1021

        reg: Reg,

1022

},

1023

1024

1025

/// Internal type DivSignedness: defined at src/isa/x64/inst.isle line 719.

1026

#[derive(Copy, Clone, PartialEq, Eq, Debug)]

1027

pub enum DivSignedness {

1028

    Signed,

1029

    Unsigned,

1030

1031

1032

/// Internal type AluRmROpcode: defined at src/isa/x64/inst.isle line 756.

1033

#[derive(Copy, Clone, PartialEq, Eq, Debug)]

1034

pub enum AluRmROpcode {

1035

    Andn,

1036

    Sarx,

1037

    Shrx,

1038

    Shlx,

1039

    Bzhi,

1040

1041

1042

/// Internal type UnaryRmRVexOpcode: defined at src/isa/x64/inst.isle line 770.

1043

#[derive(Copy, Clone, PartialEq, Eq, Debug)]

1044

pub enum UnaryRmRVexOpcode {

1045

    Blsi,

1046

    Blsmsk,

1047

    Blsr,

1048

1049

1050

/// Internal type UnaryRmRImmVexOpcode: defined at src/isa/x64/inst.isle line 775.

1051

#[derive(Copy, Clone, PartialEq, Eq, Debug)]

1052

pub enum UnaryRmRImmVexOpcode {

1053

    Rorx,

1054

1055

1056

/// Internal type Amode: defined at src/isa/x64/inst.isle line 1021.

1057

#[derive(Clone, Debug)]

1058

pub enum Amode {

1059

    ImmReg {

1060

        simm32: i32,

1061

        base: Reg,

1062

        flags: MemFlags,

1063

},

1064

    ImmRegRegShift {

1065

        simm32: i32,

1066

        base: Gpr,

1067

        index: Gpr,

1068

        shift: u8,

1069

        flags: MemFlags,

1070

},

1071

    RipRelative {

1072

        target: MachLabel,

1073

},

1074

1075

1076

/// Internal type AvxOpcode: defined at src/isa/x64/inst.isle line 1207.

1077

#[derive(Copy, Clone, PartialEq, Eq, Debug)]

1078

pub enum AvxOpcode {

1079

    Vfmadd213ss,

1080

    Vfmadd213sd,

1081

    Vfmadd213ps,

1082

    Vfmadd213pd,

1083

    Vfmadd132ss,

1084

    Vfmadd132sd,

1085

    Vfmadd132ps,

1086

    Vfmadd132pd,

1087

    Vfnmadd213ss,

1088

    Vfnmadd213sd,

1089

    Vfnmadd213ps,

1090

    Vfnmadd213pd,

1091

    Vfnmadd132ss,

1092

    Vfnmadd132sd,

1093

    Vfnmadd132ps,

1094

    Vfnmadd132pd,

1095

    Vcmpps,

1096

    Vcmppd,

1097

    Vpsrlw,

1098

    Vpsrld,

1099

    Vpsrlq,

1100

    Vpaddb,

1101

    Vpaddw,

1102

    Vpaddd,

1103

    Vpaddq,

1104

    Vpaddsb,

1105

    Vpaddsw,

1106

    Vpaddusb,

1107

    Vpaddusw,

1108

    Vpsubb,

1109

    Vpsubw,

1110

    Vpsubd,

1111

    Vpsubq,

1112

    Vpsubsb,

1113

    Vpsubsw,

1114

    Vpsubusb,

1115

    Vpsubusw,

1116

    Vpavgb,

1117

    Vpavgw,

1118

    Vpand,

1119

    Vandps,

1120

    Vandpd,

1121

    Vpor,

1122

    Vorps,

1123

    Vorpd,

1124

    Vpxor,

1125

    Vxorps,

1126

    Vxorpd,

1127

    Vpmullw,

1128

    Vpmulld,

1129

    Vpmulhw,

1130

    Vpmulhd,

1131

    Vpmulhrsw,

1132

    Vpmulhuw,

1133

    Vpmuldq,

1134

    Vpmuludq,

1135

    Vpunpckhwd,

1136

    Vpunpcklwd,

1137

    Vunpcklps,

1138

    Vunpckhps,

1139

    Vandnps,

1140

    Vandnpd,

1141

    Vpandn,

1142

    Vaddps,

1143

    Vaddpd,

1144

    Vsubps,

1145

    Vsubpd,

1146

    Vmulps,

1147

    Vmulpd,

1148

    Vdivps,

1149

    Vdivpd,

1150

    Vpcmpeqb,

1151

    Vpcmpeqw,

1152

    Vpcmpeqd,

1153

    Vpcmpeqq,

1154

    Vpcmpgtb,

1155

    Vpcmpgtw,

1156

    Vpcmpgtd,

1157

    Vpcmpgtq,

1158

    Vminps,

1159

    Vminpd,

1160

    Vmaxps,

1161

    Vmaxpd,

1162

    Vblendvpd,

1163

    Vblendvps,

1164

    Vpblendvb,

1165

    Vmovlhps,

1166

    Vpmaxsb,

1167

    Vpmaxsw,

1168

    Vpmaxsd,

1169

    Vpminsb,

1170

    Vpminsw,

1171

    Vpminsd,

1172

    Vpmaxub,

1173

    Vpmaxuw,

1174

    Vpmaxud,

1175

    Vpminub,

1176

    Vpminuw,

1177

    Vpminud,

1178

    Vpunpcklbw,

1179

    Vpunpckhbw,

1180

    Vpacksswb,

1181

    Vpackssdw,

1182

    Vpackuswb,

1183

    Vpackusdw,

1184

    Vpalignr,

1185

    Vpinsrb,

1186

    Vpinsrw,

1187

    Vpinsrd,

1188

    Vpinsrq,

1189

    Vpmaddwd,

1190

    Vpmaddubsw,

1191

    Vinsertps,

1192

    Vpshufb,

1193

    Vshufps,

1194

    Vpsllw,

1195

    Vpslld,

1196

    Vpsllq,

1197

    Vpsraw,

1198

    Vpsrad,

1199

    Vpmovsxbw,

1200

    Vpmovzxbw,

1201

    Vpmovsxwd,

1202

    Vpmovzxwd,

1203

    Vpmovsxdq,

1204

    Vpmovzxdq,

1205

    Vaddss,

1206

    Vaddsd,

1207

    Vmulss,

1208

    Vmulsd,

1209

    Vsubss,

1210

    Vsubsd,

1211

    Vdivss,

1212

    Vdivsd,

1213

    Vpabsb,

1214

    Vpabsw,

1215

    Vpabsd,

1216

    Vminss,

1217

    Vminsd,

1218

    Vmaxss,

1219

    Vmaxsd,

1220

    Vsqrtps,

1221

    Vsqrtpd,

1222

    Vroundps,

1223

    Vroundpd,

1224

    Vcvtdq2pd,

1225

    Vcvtdq2ps,

1226

    Vcvtpd2ps,

1227

    Vcvtps2pd,

1228

    Vcvttpd2dq,

1229

    Vcvttps2dq,

1230

    Vphaddw,

1231

    Vphaddd,

1232

    Vpunpckhdq,

1233

    Vpunpckldq,

1234

    Vpunpckhqdq,

1235

    Vpunpcklqdq,

1236

    Vpshuflw,

1237

    Vpshufhw,

1238

    Vpshufd,

1239

    Vmovss,

1240

    Vmovsd,

1241

    Vmovups,

1242

    Vmovupd,

1243

    Vmovdqu,

1244

    Vpextrb,

1245

    Vpextrw,

1246

    Vpextrd,

1247

    Vpextrq,

1248

    Vpblendw,

1249

    Vmovddup,

1250

    Vpbroadcastb,

1251

    Vpbroadcastw,

1252

    Vpbroadcastd,

1253

    Vbroadcastss,

1254

    Vmovd,

1255

    Vmovq,

1256

    Vmovmskps,

1257

    Vmovmskpd,

1258

    Vpmovmskb,

1259

    Vcvtsi2ss,

1260

    Vcvtsi2sd,

1261

    Vcvtss2sd,

1262

    Vcvtsd2ss,

1263

    Vsqrtss,

1264

    Vsqrtsd,

1265

    Vroundss,

1266

    Vroundsd,

1267

1268

1269

/// Internal type Avx512Opcode: defined at src/isa/x64/inst.isle line 1398.

1270

#[derive(Copy, Clone, PartialEq, Eq, Debug)]

1271

pub enum Avx512Opcode {

1272

    Vcvtudq2ps,

1273

    Vpabsq,

1274

    Vpermi2b,

1275

    Vpmullq,

1276

    Vpopcntb,

1277

    Vpsraq,

1278

    VpsraqImm,

1279

1280

1281

/// Internal type RegisterClass: defined at src/isa/x64/inst.isle line 1674.

1282

#[derive(Clone, Debug)]

1283

pub enum RegisterClass {

1284

    Gpr { single_register: bool },

1285

    Xmm,

1286

1287

1288

/// Internal type ExtendKind: defined at src/isa/x64/inst.isle line 2144.

1289

#[derive(Copy, Clone, PartialEq, Eq, Debug)]

1290

pub enum ExtendKind {

1291

    Sign,

1292

    Zero,

1293

1294

1295

/// Internal type IcmpCondResult: defined at src/isa/x64/inst.isle line 4644.

1296

#[derive(Clone, Debug)]

1297

pub enum IcmpCondResult {

1298

    Condition { producer: ProducesFlags, cc: CC },

1299

1300

1301

/// Internal type FcmpCondResult: defined at src/isa/x64/inst.isle line 4757.

1302

#[derive(Clone, Debug)]

1303

pub enum FcmpCondResult {

1304

    Condition {

1305

        producer: ProducesFlags,

1306

        cc: CC,

1307

},

1308

    AndCondition {

1309

        producer: ProducesFlags,

1310

        cc1: CC,

1311

        cc2: CC,

1312

},

1313

    OrCondition {

1314

        producer: ProducesFlags,

1315

        cc1: CC,

1316

        cc2: CC,

1317

},

1318

1319

1320

// Generated as internal constructor for term output_reg.

1321

pub fn constructor_output_reg<C: Context>(ctx: &mut C, arg0: Reg) -> InstOutput {

1322

    let v1 = C::value_reg(ctx, arg0);

1323

    let v2 = C::output(ctx, v1);

1324

    // Rule at src/prelude_lower.isle line 73.

1325

    return v2;

1326

1327

1328

// Generated as internal constructor for term output_value.

1329

pub fn constructor_output_value<C: Context>(ctx: &mut C, arg0: Value) -> InstOutput {

1330

    let v1 = C::put_in_regs(ctx, arg0);

1331

    let v2 = C::output(ctx, v1);

1332

    // Rule at src/prelude_lower.isle line 77.

1333

    return v2;

1334

1335

1336

// Generated as internal constructor for term temp_reg.

1337

pub fn constructor_temp_reg<C: Context>(ctx: &mut C, arg0: Type) -> Reg {

1338

    let v1 = C::temp_writable_reg(ctx, arg0);

1339

    let v2 = C::writable_reg_to_reg(ctx, v1);

1340

    // Rule at src/prelude_lower.isle line 97.

1341

    return v2;

1342

1343

1344

// Generated as internal constructor for term value_regs_range.

1345

pub fn constructor_value_regs_range<C: Context>(ctx: &mut C, arg0: ValueRegs) -> Range {

1346

    let v2 = C::value_regs_len(ctx, arg0);

1347

    let v3 = C::range(ctx, 0x0, v2);

1348

    // Rule at src/prelude_lower.isle line 146.

1349

    return v3;

1350

1351

1352

// Generated as internal constructor for term lo_reg.

1353

pub fn constructor_lo_reg<C: Context>(ctx: &mut C, arg0: Value) -> Reg {

1354

    let v1 = C::put_in_regs(ctx, arg0);

1355

    let v3 = C::value_regs_get(ctx, v1, 0x0);

1356

    // Rule at src/prelude_lower.isle line 157.

1357

    return v3;

1358

1359

1360

// Generated as internal constructor for term multi_reg_to_pair_and_single.

1361

pub fn constructor_multi_reg_to_pair_and_single<C: Context>(

1362

    ctx: &mut C,

1363

    arg0: &MultiReg,

1364

) -> InstOutput {

1365

    if let &MultiReg::Three {

1366

        a: v1,

1367

        b: v2,

1368

        c: v3,

1369

    } = arg0

1370

1371

        let v4 = C::value_regs(ctx, v1, v2);

1372

        let v5 = C::value_reg(ctx, v3);

1373

        let v6 = C::output_pair(ctx, v4, v5);

1374

        // Rule at src/prelude_lower.isle line 168.

1375

        return v6;

1376

1377

    unreachable!(

1378

        "no rule matched for term {} at {}; should it be partial?",

1379

        "multi_reg_to_pair_and_single", "src/prelude_lower.isle line 167"

1380

1381

1382

1383

// Generated as internal constructor for term multi_reg_to_pair.

1384

pub fn constructor_multi_reg_to_pair<C: Context>(ctx: &mut C, arg0: &MultiReg) -> InstOutput {

1385

    if let &MultiReg::Two { a: v1, b: v2 } = arg0 {

1386

        let v3 = C::value_regs(ctx, v1, v2);

1387

        let v4 = C::output(ctx, v3);

1388

        // Rule at src/prelude_lower.isle line 173.

1389

        return v4;

1390

1391

    unreachable!(

1392

        "no rule matched for term {} at {}; should it be partial?",

1393

        "multi_reg_to_pair", "src/prelude_lower.isle line 172"

1394

1395

1396

1397

// Generated as internal constructor for term multi_reg_to_single.

1398

pub fn constructor_multi_reg_to_single<C: Context>(ctx: &mut C, arg0: &MultiReg) -> InstOutput {

1399

    if let &MultiReg::One { a: v1 } = arg0 {

1400

        let v2 = C::value_reg(ctx, v1);

1401

        let v3 = C::output(ctx, v2);

1402

        // Rule at src/prelude_lower.isle line 178.

1403

        return v3;

1404

1405

    unreachable!(

1406

        "no rule matched for term {} at {}; should it be partial?",

1407

        "multi_reg_to_single", "src/prelude_lower.isle line 177"

1408

1409

1410

1411

// Generated as internal constructor for term emit_side_effect.

1412

pub fn constructor_emit_side_effect<C: Context>(ctx: &mut C, arg0: &SideEffectNoResult) -> Unit {

1413

    match arg0 {

1414

        &SideEffectNoResult::Inst { inst: ref v1 } => {

1415

            let v2 = C::emit(ctx, v1);

1416

            // Rule at src/prelude_lower.isle line 350.

1417

            return v2;

1418

1419

        &SideEffectNoResult::Inst2 {

1420

            inst1: ref v3,

1421

            inst2: ref v4,

1422

        } => {

1423

            let v5 = C::emit(ctx, v3);

1424

            let v6 = C::emit(ctx, v4);

1425

            // Rule at src/prelude_lower.isle line 352.

1426

            return v6;

1427

1428

        &SideEffectNoResult::Inst3 {

1429

            inst1: ref v7,

1430

            inst2: ref v8,

1431

            inst3: ref v9,

1432

        } => {

1433

            let v10 = C::emit(ctx, v7);

1434

            let v11 = C::emit(ctx, v8);

1435

            let v12 = C::emit(ctx, v9);

1436

            // Rule at src/prelude_lower.isle line 355.

1437

            return v12;

1438

1439

        _ => {}

1440

1441

    unreachable!(

1442

        "no rule matched for term {} at {}; should it be partial?",

1443

        "emit_side_effect", "src/prelude_lower.isle line 349"

1444

1445

1446

1447

// Generated as internal constructor for term side_effect.

1448

pub fn constructor_side_effect<C: Context>(ctx: &mut C, arg0: &SideEffectNoResult) -> InstOutput {

1449

    let v1 = constructor_emit_side_effect(ctx, arg0);

1450

    let v2 = C::output_none(ctx);

1451

    // Rule at src/prelude_lower.isle line 363.

1452

    return v2;

1453

1454

1455

// Generated as internal constructor for term side_effect_concat.

1456

pub fn constructor_side_effect_concat<C: Context>(

1457

    ctx: &mut C,

1458

    arg0: &SideEffectNoResult,

1459

    arg1: &SideEffectNoResult,

1460

) -> SideEffectNoResult {

1461

    match arg0 {

1462

        &SideEffectNoResult::Inst { inst: ref v1 } => {

1463

            match arg1 {

1464

                &SideEffectNoResult::Inst { inst: ref v3 } => {

1465

                    let v4 = SideEffectNoResult::Inst2 {

1466

                        inst1: v1.clone(),

1467

                        inst2: v3.clone(),

1468

};

1469

                    // Rule at src/prelude_lower.isle line 368.

1470

                    return v4;

1471

1472

                &SideEffectNoResult::Inst2 {

1473

                    inst1: ref v5,

1474

                    inst2: ref v6,

1475

                } => {

1476

                    let v7 = SideEffectNoResult::Inst3 {

1477

                        inst1: v1.clone(),

1478

                        inst2: v5.clone(),

1479

                        inst3: v6.clone(),

1480

};

1481

                    // Rule at src/prelude_lower.isle line 370.

1482

                    return v7;

1483

1484

                _ => {}

1485

1486

1487

        &SideEffectNoResult::Inst2 {

1488

            inst1: ref v8,

1489

            inst2: ref v9,

1490

        } => {

1491

            if let &SideEffectNoResult::Inst { inst: ref v3 } = arg1 {

1492

                let v10 = SideEffectNoResult::Inst3 {

1493

                    inst1: v8.clone(),

1494

                    inst2: v9.clone(),

1495

                    inst3: v3.clone(),

1496

};

1497

                // Rule at src/prelude_lower.isle line 372.

1498

                return v10;

1499

1500

1501

        _ => {}

1502

1503

    unreachable!(

1504

        "no rule matched for term {} at {}; should it be partial?",

1505

        "side_effect_concat", "src/prelude_lower.isle line 367"

1506

1507

1508

1509

// Generated as internal constructor for term produces_flags_concat.

1510

pub fn constructor_produces_flags_concat<C: Context>(

1511

    ctx: &mut C,

1512

    arg0: &ProducesFlags,

1513

    arg1: &ProducesFlags,

1514

) -> ProducesFlags {

1515

    if let &ProducesFlags::ProducesFlagsSideEffect { inst: ref v1 } = arg0 {

1516

        if let &ProducesFlags::ProducesFlagsSideEffect { inst: ref v3 } = arg1 {

1517

            let v4 = ProducesFlags::ProducesFlagsTwiceSideEffect {

1518

                inst1: v1.clone(),

1519

                inst2: v3.clone(),

1520

};

1521

            // Rule at src/prelude_lower.isle line 397.

1522

            return v4;

1523

1524

1525

    unreachable!(

1526

        "no rule matched for term {} at {}; should it be partial?",

1527

        "produces_flags_concat", "src/prelude_lower.isle line 396"

1528

1529

1530

1531

// Generated as internal constructor for term produces_flags_get_reg.

1532

pub fn constructor_produces_flags_get_reg<C: Context>(ctx: &mut C, arg0: &ProducesFlags) -> Reg {

1533

    match arg0 {

1534

        &ProducesFlags::ProducesFlagsReturnsReg {

1535

            inst: ref v1,

1536

            result: v2,

1537

        } => {

1538

            // Rule at src/prelude_lower.isle line 427.

1539

            return v2;

1540

1541

        &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {

1542

            inst: ref v3,

1543

            result: v4,

1544

        } => {

1545

            // Rule at src/prelude_lower.isle line 428.

1546

            return v4;

1547

1548

        _ => {}

1549

1550

    unreachable!(

1551

        "no rule matched for term {} at {}; should it be partial?",

1552

        "produces_flags_get_reg", "src/prelude_lower.isle line 426"

1553

1554

1555

1556

// Generated as internal constructor for term produces_flags_ignore.

1557

pub fn constructor_produces_flags_ignore<C: Context>(

1558

    ctx: &mut C,

1559

    arg0: &ProducesFlags,

1560

) -> ProducesFlags {

1561

    match arg0 {

1562

        &ProducesFlags::ProducesFlagsReturnsReg {

1563

            inst: ref v1,

1564

            result: v2,

1565

        } => {

1566

            let v3 = ProducesFlags::ProducesFlagsSideEffect { inst: v1.clone() };

1567

            // Rule at src/prelude_lower.isle line 433.

1568

            return v3;

1569

1570

        &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {

1571

            inst: ref v4,

1572

            result: v5,

1573

        } => {

1574

            let v6 = ProducesFlags::ProducesFlagsSideEffect { inst: v4.clone() };

1575

            // Rule at src/prelude_lower.isle line 435.

1576

            return v6;

1577

1578

        _ => {}

1579

1580

    unreachable!(

1581

        "no rule matched for term {} at {}; should it be partial?",

1582

        "produces_flags_ignore", "src/prelude_lower.isle line 432"

1583

1584

1585

1586

// Generated as internal constructor for term consumes_flags_concat.

1587

pub fn constructor_consumes_flags_concat<C: Context>(

1588

    ctx: &mut C,

1589

    arg0: &ConsumesFlags,

1590

    arg1: &ConsumesFlags,

1591

) -> ConsumesFlags {

1592

    match arg0 {

1593

        &ConsumesFlags::ConsumesFlagsSideEffect { inst: ref v8 } => {

1594

            if let &ConsumesFlags::ConsumesFlagsSideEffect { inst: ref v9 } = arg1 {

1595

                let v10 = ConsumesFlags::ConsumesFlagsSideEffect2 {

1596

                    inst1: v8.clone(),

1597

                    inst2: v9.clone(),

1598

};

1599

                // Rule at src/prelude_lower.isle line 448.

1600

                return v10;

1601

1602

1603

        &ConsumesFlags::ConsumesFlagsReturnsReg {

1604

            inst: ref v1,

1605

            result: v2,

1606

        } => {

1607

            if let &ConsumesFlags::ConsumesFlagsReturnsReg {

1608

                inst: ref v4,

1609

                result: v5,

1610

            } = arg1

1611

1612

                let v6 = C::value_regs(ctx, v2, v5);

1613

                let v7 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {

1614

                    inst1: v1.clone(),

1615

                    inst2: v4.clone(),

1616

                    result: v6,

1617

};

1618

                // Rule at src/prelude_lower.isle line 442.

1619

                return v7;

1620

1621

1622

        _ => {}

1623

1624

    unreachable!(

1625

        "no rule matched for term {} at {}; should it be partial?",

1626

        "consumes_flags_concat", "src/prelude_lower.isle line 441"

1627

1628

1629

1630

// Generated as internal constructor for term with_flags.

1631

pub fn constructor_with_flags<C: Context>(

1632

    ctx: &mut C,

1633

    arg0: &ProducesFlags,

1634

    arg1: &ConsumesFlags,

1635

) -> ValueRegs {

1636

    match arg0 {

1637

        &ProducesFlags::ProducesFlagsSideEffect { inst: ref v12 } => {

1638

            match arg1 {

1639

                &ConsumesFlags::ConsumesFlagsReturnsReg {

1640

                    inst: ref v13,

1641

                    result: v14,

1642

                } => {

1643

                    let v15 = C::emit(ctx, v12);

1644

                    let v16 = C::emit(ctx, v13);

1645

                    let v17 = C::value_reg(ctx, v14);

1646

                    // Rule at src/prelude_lower.isle line 479.

1647

                    return v17;

1648

1649

                &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {

1650

                    inst1: ref v18,

1651

                    inst2: ref v19,

1652

                    result: v20,

1653

                } => {

1654

                    let v15 = C::emit(ctx, v12);

1655

                    let v21 = C::emit(ctx, v18);

1656

                    let v22 = C::emit(ctx, v19);

1657

                    // Rule at src/prelude_lower.isle line 485.

1658

                    return v20;

1659

1660

                &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {

1661

                    inst1: ref v23,

1662

                    inst2: ref v24,

1663

                    inst3: ref v25,

1664

                    inst4: ref v26,

1665

                    result: v27,

1666

                } => {

1667

                    let v15 = C::emit(ctx, v12);

1668

                    let v28 = C::emit(ctx, v23);

1669

                    let v29 = C::emit(ctx, v24);

1670

                    let v30 = C::emit(ctx, v25);

1671

                    let v31 = C::emit(ctx, v26);

1672

                    // Rule at src/prelude_lower.isle line 497.

1673

                    return v27;

1674

1675

                _ => {}

1676

1677

1678

        &ProducesFlags::ProducesFlagsTwiceSideEffect {

1679

            inst1: ref v32,

1680

            inst2: ref v33,

1681

        } => {

1682

            match arg1 {

1683

                &ConsumesFlags::ConsumesFlagsReturnsReg {

1684

                    inst: ref v13,

1685

                    result: v14,

1686

                } => {

1687

                    let v34 = C::emit(ctx, v32);

1688

                    let v35 = C::emit(ctx, v33);

1689

                    let v36 = C::emit(ctx, v13);

1690

                    let v37 = C::value_reg(ctx, v14);

1691

                    // Rule at src/prelude_lower.isle line 513.

1692

                    return v37;

1693

1694

                &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {

1695

                    inst1: ref v18,

1696

                    inst2: ref v19,

1697

                    result: v20,

1698

                } => {

1699

                    let v34 = C::emit(ctx, v32);

1700

                    let v35 = C::emit(ctx, v33);

1701

                    let v38 = C::emit(ctx, v18);

1702

                    let v39 = C::emit(ctx, v19);

1703

                    // Rule at src/prelude_lower.isle line 520.

1704

                    return v20;

1705

1706

                &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {

1707

                    inst1: ref v23,

1708

                    inst2: ref v24,

1709

                    inst3: ref v25,

1710

                    inst4: ref v26,

1711

                    result: v27,

1712

                } => {

1713

                    let v34 = C::emit(ctx, v32);

1714

                    let v35 = C::emit(ctx, v33);

1715

                    let v40 = C::emit(ctx, v23);

1716

                    let v41 = C::emit(ctx, v24);

1717

                    let v42 = C::emit(ctx, v25);

1718

                    let v43 = C::emit(ctx, v26);

1719

                    // Rule at src/prelude_lower.isle line 533.

1720

                    return v27;

1721

1722

                _ => {}

1723

1724

1725

        &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {

1726

            inst: ref v1,

1727

            result: v2,

1728

        } => {

1729

            match arg1 {

1730

                &ConsumesFlags::ConsumesFlagsSideEffect { inst: ref v9 } => {

1731

                    let v6 = C::emit(ctx, v1);

1732

                    let v10 = C::emit(ctx, v9);

1733

                    let v11 = C::value_reg(ctx, v2);

1734

                    // Rule at src/prelude_lower.isle line 473.

1735

                    return v11;

1736

1737

                &ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {

1738

                    inst: ref v4,

1739

                    result: v5,

1740

                } => {

1741

                    let v6 = C::emit(ctx, v1);

1742

                    let v7 = C::emit(ctx, v4);

1743

                    let v8 = C::value_regs(ctx, v2, v5);

1744

                    // Rule at src/prelude_lower.isle line 465.

1745

                    return v8;

1746

1747

                _ => {}

1748

1749

1750

        _ => {}

1751

1752

    unreachable!(

1753

        "no rule matched for term {} at {}; should it be partial?",

1754

        "with_flags", "src/prelude_lower.isle line 463"

1755

1756

1757

1758

// Generated as internal constructor for term with_flags_reg.

1759

pub fn constructor_with_flags_reg<C: Context>(

1760

    ctx: &mut C,

1761

    arg0: &ProducesFlags,

1762

    arg1: &ConsumesFlags,

1763

) -> Reg {

1764

    let v2 = constructor_with_flags(ctx, arg0, arg1);

1765

    let v4 = C::value_regs_get(ctx, v2, 0x0);

1766

    // Rule at src/prelude_lower.isle line 551.

1767

    return v4;

1768

1769

1770

// Generated as internal constructor for term flags_to_producesflags.

1771

pub fn constructor_flags_to_producesflags<C: Context>(ctx: &mut C, arg0: Value) -> ProducesFlags {

1772

    let v1 = C::mark_value_used(ctx, arg0);

1773

    // Rule at src/prelude_lower.isle line 558.

1774

    return ProducesFlags::AlreadyExistingFlags;

1775

1776

1777

// Generated as internal constructor for term with_flags_side_effect.

1778

pub fn constructor_with_flags_side_effect<C: Context>(

1779

    ctx: &mut C,

1780

    arg0: &ProducesFlags,

1781

    arg1: &ConsumesFlags,

1782

) -> SideEffectNoResult {

1783

    match arg0 {

1784

        &ProducesFlags::AlreadyExistingFlags => {

1785

            match arg1 {

1786

                &ConsumesFlags::ConsumesFlagsSideEffect { inst: ref v2 } => {

1787

                    let v3 = SideEffectNoResult::Inst { inst: v2.clone() };

1788

                    // Rule at src/prelude_lower.isle line 569.

1789

                    return v3;

1790

1791

                &ConsumesFlags::ConsumesFlagsSideEffect2 {

1792

                    inst1: ref v4,

1793

                    inst2: ref v5,

1794

                } => {

1795

                    let v6 = SideEffectNoResult::Inst2 {

1796

                        inst1: v4.clone(),

1797

                        inst2: v5.clone(),

1798

};

1799

                    // Rule at src/prelude_lower.isle line 574.

1800

                    return v6;

1801

1802

                _ => {}

1803

1804

1805

        &ProducesFlags::ProducesFlagsSideEffect { inst: ref v7 } => {

1806

            match arg1 {

1807

                &ConsumesFlags::ConsumesFlagsSideEffect { inst: ref v2 } => {

1808

                    let v8 = SideEffectNoResult::Inst2 {

1809

                        inst1: v7.clone(),

1810

                        inst2: v2.clone(),

1811

};

1812

                    // Rule at src/prelude_lower.isle line 579.

1813

                    return v8;

1814

1815

                &ConsumesFlags::ConsumesFlagsSideEffect2 {

1816

                    inst1: ref v4,

1817

                    inst2: ref v5,

1818

                } => {

1819

                    let v9 = SideEffectNoResult::Inst3 {

1820

                        inst1: v7.clone(),

1821

                        inst2: v4.clone(),

1822

                        inst3: v5.clone(),

1823

};

1824

                    // Rule at src/prelude_lower.isle line 584.

1825

                    return v9;

1826

1827

                _ => {}

1828

1829

1830

        &ProducesFlags::ProducesFlagsTwiceSideEffect {

1831

            inst1: ref v10,

1832

            inst2: ref v11,

1833

        } => {

1834

            if let &ConsumesFlags::ConsumesFlagsSideEffect { inst: ref v2 } = arg1 {

1835

                let v12 = SideEffectNoResult::Inst3 {

1836

                    inst1: v10.clone(),

1837

                    inst2: v11.clone(),

1838

                    inst3: v2.clone(),

1839

};

1840

                // Rule at src/prelude_lower.isle line 589.

1841

                return v12;

1842

1843

1844

        _ => {}

1845

1846

    unreachable!(

1847

        "no rule matched for term {} at {}; should it be partial?",

1848

        "with_flags_side_effect", "src/prelude_lower.isle line 567"

1849

1850

1851

1852

// Generated as internal constructor for term with_flags_chained.

1853

pub fn constructor_with_flags_chained<C: Context>(

1854

    ctx: &mut C,

1855

    arg0: &ProducesFlags,

1856

    arg1: &ConsumesAndProducesFlags,

1857

    arg2: &ConsumesFlags,

1858

) -> MultiReg {

1859

    match arg0 {

1860

        &ProducesFlags::ProducesFlagsSideEffect { inst: ref v1 } => {

1861

            match arg1 {

1862

                &ConsumesAndProducesFlags::SideEffect { inst: ref v3 } => {

1863

                    match arg2 {

1864

                        &ConsumesFlags::ConsumesFlagsSideEffect { inst: ref v5 } => {

1865

                            let v6 = C::emit(ctx, v1);

1866

                            let v7 = C::emit(ctx, v3);

1867

                            let v8 = C::emit(ctx, v5);

1868

                            // Rule at src/prelude_lower.isle line 598.

1869

                            return MultiReg::Empty;

1870

1871

                        &ConsumesFlags::ConsumesFlagsSideEffect2 {

1872

                            inst1: ref v10,

1873

                            inst2: ref v11,

1874

                        } => {

1875

                            let v6 = C::emit(ctx, v1);

1876

                            let v7 = C::emit(ctx, v3);

1877

                            let v12 = C::emit(ctx, v10);

1878

                            let v13 = C::emit(ctx, v11);

1879

                            // Rule at src/prelude_lower.isle line 606.

1880

                            return MultiReg::Empty;

1881

1882

                        &ConsumesFlags::ConsumesFlagsReturnsReg {

1883

                            inst: ref v14,

1884

                            result: v15,

1885

                        } => {

1886

                            let v6 = C::emit(ctx, v1);

1887

                            let v7 = C::emit(ctx, v3);

1888

                            let v16 = C::emit(ctx, v14);

1889

                            let v17 = MultiReg::One { a: v15 };

1890

                            // Rule at src/prelude_lower.isle line 615.

1891

                            return v17;

1892

1893

                        &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {

1894

                            inst1: ref v18,

1895

                            inst2: ref v19,

1896

                            result: v20,

1897

                        } => {

1898

                            let v6 = C::emit(ctx, v1);

1899

                            let v7 = C::emit(ctx, v3);

1900

                            let v21 = C::emit(ctx, v18);

1901

                            let v22 = C::emit(ctx, v19);

1902

                            let v24 = C::value_regs_get(ctx, v20, 0x0);

1903

                            let v26 = C::value_regs_get(ctx, v20, 0x1);

1904

                            let v27 = MultiReg::Two { a: v24, b: v26 };

1905

                            // Rule at src/prelude_lower.isle line 623.

1906

                            return v27;

1907

1908

                        &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {

1909

                            inst1: ref v28,

1910

                            inst2: ref v29,

1911

                            inst3: ref v30,

1912

                            inst4: ref v31,

1913

                            result: v32,

1914

                        } => {

1915

                            let v6 = C::emit(ctx, v1);

1916

                            let v7 = C::emit(ctx, v3);

1917

                            let v33 = C::emit(ctx, v28);

1918

                            let v34 = C::emit(ctx, v29);

1919

                            let v35 = C::emit(ctx, v30);

1920

                            let v36 = C::emit(ctx, v31);

1921

                            let v37 = C::value_regs_get(ctx, v32, 0x0);

1922

                            let v38 = C::value_regs_get(ctx, v32, 0x1);

1923

                            let v39 = MultiReg::Two { a: v37, b: v38 };

1924

                            // Rule at src/prelude_lower.isle line 632.

1925

                            return v39;

1926

1927

                        _ => {}

1928

1929

1930

                &ConsumesAndProducesFlags::ReturnsReg {

1931

                    inst: ref v47,

1932

                    result: v48,

1933

                } => {

1934

                    match arg2 {

1935

                        &ConsumesFlags::ConsumesFlagsSideEffect { inst: ref v5 } => {

1936

                            let v6 = C::emit(ctx, v1);

1937

                            let v49 = C::emit(ctx, v47);

1938

                            let v8 = C::emit(ctx, v5);

1939

                            let v50 = MultiReg::One { a: v48 };

1940

                            // Rule at src/prelude_lower.isle line 692.

1941

                            return v50;

1942

1943

                        &ConsumesFlags::ConsumesFlagsSideEffect2 {

1944

                            inst1: ref v10,

1945

                            inst2: ref v11,

1946

                        } => {

1947

                            let v6 = C::emit(ctx, v1);

1948

                            let v49 = C::emit(ctx, v47);

1949

                            let v12 = C::emit(ctx, v10);

1950

                            let v13 = C::emit(ctx, v11);

1951

                            let v50 = MultiReg::One { a: v48 };

1952

                            // Rule at src/prelude_lower.isle line 700.

1953

                            return v50;

1954

1955

                        &ConsumesFlags::ConsumesFlagsReturnsReg {

1956

                            inst: ref v14,

1957

                            result: v15,

1958

                        } => {

1959

                            let v6 = C::emit(ctx, v1);

1960

                            let v49 = C::emit(ctx, v47);

1961

                            let v16 = C::emit(ctx, v14);

1962

                            let v51 = MultiReg::Two { a: v48, b: v15 };

1963

                            // Rule at src/prelude_lower.isle line 709.

1964

                            return v51;

1965

1966

                        &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {

1967

                            inst1: ref v18,

1968

                            inst2: ref v19,

1969

                            result: v20,

1970

                        } => {

1971

                            let v6 = C::emit(ctx, v1);

1972

                            let v49 = C::emit(ctx, v47);

1973

                            let v21 = C::emit(ctx, v18);

1974

                            let v22 = C::emit(ctx, v19);

1975

                            let v24 = C::value_regs_get(ctx, v20, 0x0);

1976

                            let v26 = C::value_regs_get(ctx, v20, 0x1);

1977

                            let v52 = MultiReg::Three {

1978

                                a: v48,

1979

                                b: v24,

1980

                                c: v26,

1981

};

1982

                            // Rule at src/prelude_lower.isle line 717.

1983

                            return v52;

1984

1985

                        &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {

1986

                            inst1: ref v28,

1987

                            inst2: ref v29,

1988

                            inst3: ref v30,

1989

                            inst4: ref v31,

1990

                            result: v32,

1991

                        } => {

1992

                            let v6 = C::emit(ctx, v1);

1993

                            let v49 = C::emit(ctx, v47);

1994

                            let v33 = C::emit(ctx, v28);

1995

                            let v34 = C::emit(ctx, v29);

1996

                            let v35 = C::emit(ctx, v30);

1997

                            let v36 = C::emit(ctx, v31);

1998

                            let v37 = C::value_regs_get(ctx, v32, 0x0);

1999

                            let v38 = C::value_regs_get(ctx, v32, 0x1);

2000

                            let v53 = MultiReg::Three {

2001

                                a: v48,

2002

                                b: v37,

2003

                                c: v38,

2004

};

2005

                            // Rule at src/prelude_lower.isle line 726.

2006

                            return v53;

2007

2008

                        _ => {}

2009

2010

2011

                _ => {}

2012

2013

2014

        &ProducesFlags::ProducesFlagsReturnsReg {

2015

            inst: ref v40,

2016

            result: v41,

2017

        } => {

2018

            match arg1 {

2019

                &ConsumesAndProducesFlags::SideEffect { inst: ref v3 } => {

2020

                    match arg2 {

2021

                        &ConsumesFlags::ConsumesFlagsSideEffect { inst: ref v5 } => {

2022

                            let v42 = C::emit(ctx, v40);

2023

                            let v7 = C::emit(ctx, v3);

2024

                            let v8 = C::emit(ctx, v5);

2025

                            let v43 = MultiReg::One { a: v41 };

2026

                            // Rule at src/prelude_lower.isle line 645.

2027

                            return v43;

2028

2029

                        &ConsumesFlags::ConsumesFlagsSideEffect2 {

2030

                            inst1: ref v10,

2031

                            inst2: ref v11,

2032

                        } => {

2033

                            let v42 = C::emit(ctx, v40);

2034

                            let v7 = C::emit(ctx, v3);

2035

                            let v12 = C::emit(ctx, v10);

2036

                            let v13 = C::emit(ctx, v11);

2037

                            let v43 = MultiReg::One { a: v41 };

2038

                            // Rule at src/prelude_lower.isle line 653.

2039

                            return v43;

2040

2041

                        &ConsumesFlags::ConsumesFlagsReturnsReg {

2042

                            inst: ref v14,

2043

                            result: v15,

2044

                        } => {

2045

                            let v42 = C::emit(ctx, v40);

2046

                            let v7 = C::emit(ctx, v3);

2047

                            let v16 = C::emit(ctx, v14);

2048

                            let v44 = MultiReg::Two { a: v41, b: v15 };

2049

                            // Rule at src/prelude_lower.isle line 662.

2050

                            return v44;

2051

2052

                        &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {

2053

                            inst1: ref v18,

2054

                            inst2: ref v19,

2055

                            result: v20,

2056

                        } => {

2057

                            let v42 = C::emit(ctx, v40);

2058

                            let v7 = C::emit(ctx, v3);

2059

                            let v21 = C::emit(ctx, v18);

2060

                            let v22 = C::emit(ctx, v19);

2061

                            let v24 = C::value_regs_get(ctx, v20, 0x0);

2062

                            let v26 = C::value_regs_get(ctx, v20, 0x1);

2063

                            let v45 = MultiReg::Three {

2064

                                a: v41,

2065

                                b: v24,

2066

                                c: v26,

2067

};

2068

                            // Rule at src/prelude_lower.isle line 670.

2069

                            return v45;

2070

2071

                        &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {

2072

                            inst1: ref v28,

2073

                            inst2: ref v29,

2074

                            inst3: ref v30,

2075

                            inst4: ref v31,

2076

                            result: v32,

2077

                        } => {

2078

                            let v42 = C::emit(ctx, v40);

2079

                            let v7 = C::emit(ctx, v3);

2080

                            let v33 = C::emit(ctx, v28);

2081

                            let v34 = C::emit(ctx, v29);

2082

                            let v35 = C::emit(ctx, v30);

2083

                            let v36 = C::emit(ctx, v31);

2084

                            let v37 = C::value_regs_get(ctx, v32, 0x0);

2085

                            let v38 = C::value_regs_get(ctx, v32, 0x1);

2086

                            let v46 = MultiReg::Three {

2087

                                a: v41,

2088

                                b: v37,

2089

                                c: v38,

2090

};

2091

                            // Rule at src/prelude_lower.isle line 679.

2092

                            return v46;

2093

2094

                        _ => {}

2095

2096

2097

                &ConsumesAndProducesFlags::ReturnsReg {

2098

                    inst: ref v47,

2099

                    result: v48,

2100

                } => {

2101

                    match arg2 {

2102

                        &ConsumesFlags::ConsumesFlagsSideEffect { inst: ref v5 } => {

2103

                            let v42 = C::emit(ctx, v40);

2104

                            let v49 = C::emit(ctx, v47);

2105

                            let v8 = C::emit(ctx, v5);

2106

                            let v54 = MultiReg::Two { a: v41, b: v48 };

2107

                            // Rule at src/prelude_lower.isle line 739.

2108

                            return v54;

2109

2110

                        &ConsumesFlags::ConsumesFlagsSideEffect2 {

2111

                            inst1: ref v10,

2112

                            inst2: ref v11,

2113

                        } => {

2114

                            let v42 = C::emit(ctx, v40);

2115

                            let v49 = C::emit(ctx, v47);

2116

                            let v12 = C::emit(ctx, v10);

2117

                            let v13 = C::emit(ctx, v11);

2118

                            let v54 = MultiReg::Two { a: v41, b: v48 };

2119

                            // Rule at src/prelude_lower.isle line 747.

2120

                            return v54;

2121

2122

                        &ConsumesFlags::ConsumesFlagsReturnsReg {

2123

                            inst: ref v14,

2124

                            result: v15,

2125

                        } => {

2126

                            let v42 = C::emit(ctx, v40);

2127

                            let v49 = C::emit(ctx, v47);

2128

                            let v16 = C::emit(ctx, v14);

2129

                            let v55 = MultiReg::Three {

2130

                                a: v41,

2131

                                b: v48,

2132

                                c: v15,

2133

};

2134

                            // Rule at src/prelude_lower.isle line 756.

2135

                            return v55;

2136

2137

                        &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {

2138

                            inst1: ref v18,

2139

                            inst2: ref v19,

2140

                            result: v20,

2141

                        } => {

2142

                            let v42 = C::emit(ctx, v40);

2143

                            let v49 = C::emit(ctx, v47);

2144

                            let v21 = C::emit(ctx, v18);

2145

                            let v22 = C::emit(ctx, v19);

2146

                            let v24 = C::value_regs_get(ctx, v20, 0x0);

2147

                            let v26 = C::value_regs_get(ctx, v20, 0x1);

2148

                            let v56 = MultiReg::Four {

2149

                                a: v41,

2150

                                b: v48,

2151

                                c: v24,

2152

                                d: v26,

2153

};

2154

                            // Rule at src/prelude_lower.isle line 764.

2155

                            return v56;

2156

2157

                        &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {

2158

                            inst1: ref v28,

2159

                            inst2: ref v29,

2160

                            inst3: ref v30,

2161

                            inst4: ref v31,

2162

                            result: v32,

2163

                        } => {

2164

                            let v42 = C::emit(ctx, v40);

2165

                            let v49 = C::emit(ctx, v47);

2166

                            let v33 = C::emit(ctx, v28);

2167

                            let v34 = C::emit(ctx, v29);

2168

                            let v35 = C::emit(ctx, v30);

2169

                            let v36 = C::emit(ctx, v31);

2170

                            let v37 = C::value_regs_get(ctx, v32, 0x0);

2171

                            let v38 = C::value_regs_get(ctx, v32, 0x1);

2172

                            let v57 = MultiReg::Four {

2173

                                a: v41,

2174

                                b: v48,

2175

                                c: v37,

2176

                                d: v38,

2177

};

2178

                            // Rule at src/prelude_lower.isle line 773.

2179

                            return v57;

2180

2181

                        _ => {}

2182

2183

2184

                _ => {}

2185

2186

2187

        &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {

2188

            inst: ref v58,

2189

            result: v59,

2190

        } => {

2191

            if let &ConsumesAndProducesFlags::ReturnsReg {

2192

                inst: ref v47,

2193

                result: v48,

2194

            } = arg1

2195

2196

                match arg2 {

2197

                    &ConsumesFlags::ConsumesFlagsSideEffect { inst: ref v5 } => {

2198

                        let v60 = C::emit(ctx, v58);

2199

                        let v49 = C::emit(ctx, v47);

2200

                        let v8 = C::emit(ctx, v5);

2201

                        let v61 = MultiReg::Two { a: v59, b: v48 };

2202

                        // Rule at src/prelude_lower.isle line 785.

2203

                        return v61;

2204

2205

                    &ConsumesFlags::ConsumesFlagsSideEffect2 {

2206

                        inst1: ref v10,

2207

                        inst2: ref v11,

2208

                    } => {

2209

                        let v60 = C::emit(ctx, v58);

2210

                        let v49 = C::emit(ctx, v47);

2211

                        let v12 = C::emit(ctx, v10);

2212

                        let v13 = C::emit(ctx, v11);

2213

                        let v61 = MultiReg::Two { a: v59, b: v48 };

2214

                        // Rule at src/prelude_lower.isle line 793.

2215

                        return v61;

2216

2217

                    &ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {

2218

                        inst: ref v63,

2219

                        result: v64,

2220

                    } => {

2221

                        let v60 = C::emit(ctx, v58);

2222

                        let v49 = C::emit(ctx, v47);

2223

                        let v65 = C::emit(ctx, v63);

2224

                        let v66 = MultiReg::Three {

2225

                            a: v59,

2226

                            b: v48,

2227

                            c: v64,

2228

};

2229

                        // Rule at src/prelude_lower.isle line 810.

2230

                        return v66;

2231

2232

                    &ConsumesFlags::ConsumesFlagsReturnsReg {

2233

                        inst: ref v14,

2234

                        result: v15,

2235

                    } => {

2236

                        let v60 = C::emit(ctx, v58);

2237

                        let v49 = C::emit(ctx, v47);

2238

                        let v16 = C::emit(ctx, v14);

2239

                        let v62 = MultiReg::Three {

2240

                            a: v59,

2241

                            b: v48,

2242

                            c: v15,

2243

};

2244

                        // Rule at src/prelude_lower.isle line 802.

2245

                        return v62;

2246

2247

                    &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {

2248

                        inst1: ref v18,

2249

                        inst2: ref v19,

2250

                        result: v20,

2251

                    } => {

2252

                        let v60 = C::emit(ctx, v58);

2253

                        let v49 = C::emit(ctx, v47);

2254

                        let v21 = C::emit(ctx, v18);

2255

                        let v22 = C::emit(ctx, v19);

2256

                        let v24 = C::value_regs_get(ctx, v20, 0x0);

2257

                        let v26 = C::value_regs_get(ctx, v20, 0x1);

2258

                        let v67 = MultiReg::Four {

2259

                            a: v59,

2260

                            b: v48,

2261

                            c: v24,

2262

                            d: v26,

2263

};

2264

                        // Rule at src/prelude_lower.isle line 818.

2265

                        return v67;

2266

2267

                    &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {

2268

                        inst1: ref v28,

2269

                        inst2: ref v29,

2270

                        inst3: ref v30,

2271

                        inst4: ref v31,

2272

                        result: v32,

2273

                    } => {

2274

                        let v60 = C::emit(ctx, v58);

2275

                        let v49 = C::emit(ctx, v47);

2276

                        let v33 = C::emit(ctx, v28);

2277

                        let v34 = C::emit(ctx, v29);

2278

                        let v35 = C::emit(ctx, v30);

2279

                        let v36 = C::emit(ctx, v31);

2280

                        let v37 = C::value_regs_get(ctx, v32, 0x0);

2281

                        let v38 = C::value_regs_get(ctx, v32, 0x1);

2282

                        let v68 = MultiReg::Four {

2283

                            a: v59,

2284

                            b: v48,

2285

                            c: v37,

2286

                            d: v38,

2287

};

2288

                        // Rule at src/prelude_lower.isle line 827.

2289

                        return v68;

2290

2291

                    _ => {}

2292

2293

2294

2295

        _ => {}

2296

2297

    unreachable!(

2298

        "no rule matched for term {} at {}; should it be partial?",

2299

        "with_flags_chained", "src/prelude_lower.isle line 595"

2300

2301

2302

2303

// Generated as internal constructor for term lower_return.

2304

pub fn constructor_lower_return<C: Context>(ctx: &mut C, arg0: ValueSlice) -> InstOutput {

2305

    let v1 = C::gen_return(ctx, arg0);

2306

    let v2 = C::output_none(ctx);

2307

    // Rule at src/prelude_lower.isle line 1027.

2308

    return v2;

2309

2310

2311

// Generated as internal constructor for term operand_size_bits.

2312

pub fn constructor_operand_size_bits<C: Context>(ctx: &mut C, arg0: &OperandSize) -> u16 {

2313

    match arg0 {

2314

        &OperandSize::Size8 => {

2315

            // Rule at src/isa/x64/inst.isle line 741.

2316

            return 0x8;

2317

2318

        &OperandSize::Size16 => {

2319

            // Rule at src/isa/x64/inst.isle line 742.

2320

            return 0x10;

2321

2322

        &OperandSize::Size32 => {

2323

            // Rule at src/isa/x64/inst.isle line 743.

2324

            return 0x20;

2325

2326

        &OperandSize::Size64 => {

2327

            // Rule at src/isa/x64/inst.isle line 744.

2328

            return 0x40;

2329

2330

        _ => {}

2331

2332

    unreachable!(

2333

        "no rule matched for term {} at {}; should it be partial?",

2334

        "operand_size_bits", "src/isa/x64/inst.isle line 740"

2335

2336

2337

2338

// Generated as internal constructor for term reg_mem_to_reg_mem_imm.

2339

pub fn constructor_reg_mem_to_reg_mem_imm<C: Context>(ctx: &mut C, arg0: &RegMem) -> RegMemImm {

2340

    match arg0 {

2341

        &RegMem::Reg { reg: v1 } => {

2342

            let v2 = RegMemImm::Reg { reg: v1 };

2343

            // Rule at src/isa/x64/inst.isle line 995.

2344

            return v2;

2345

2346

        &RegMem::Mem { addr: ref v3 } => {

2347

            let v4 = RegMemImm::Mem { addr: v3.clone() };

2348

            // Rule at src/isa/x64/inst.isle line 997.

2349

            return v4;

2350

2351

        _ => {}

2352

2353

    unreachable!(

2354

        "no rule matched for term {} at {}; should it be partial?",

2355

        "reg_mem_to_reg_mem_imm", "src/isa/x64/inst.isle line 994"

2356

2357

2358

2359

// Generated as internal constructor for term to_amode.

2360

pub fn constructor_to_amode<C: Context>(

2361

    ctx: &mut C,

2362

    arg0: MemFlags,

2363

    arg1: Value,

2364

    arg2: Offset32,

2365

) -> Amode {

2366

    let v4 = C::def_inst(ctx, arg1);

2367

    if let Some(v5) = v4 {

2368

        let v6 = &C::inst_data(ctx, v5);

2369

        if let &InstructionData::Binary {

2370

            opcode: ref v7,

2371

            args: ref v8,

2372

        } = v6

2373

2374

            if let &Opcode::Iadd = v7 {

2375

                let v9 = C::unpack_value_array_2(ctx, v8);

2376

                let v12 = &constructor_to_amode_add(ctx, arg0, v9.0, v9.1, arg2);

2377

                // Rule at src/isa/x64/inst.isle line 1083.

2378

                return v12.clone();

2379

2380

2381

2382

    let v3 = &constructor_amode_imm_reg(ctx, arg0, arg1, arg2);

2383

    // Rule at src/isa/x64/inst.isle line 1081.

2384

    return v3.clone();

2385

2386

2387

// Generated as internal constructor for term to_amode_add.

2388

pub fn constructor_to_amode_add<C: Context>(

2389

    ctx: &mut C,

2390

    arg0: MemFlags,

2391

    arg1: Value,

2392

    arg2: Value,

2393

    arg3: Offset32,

2394

) -> Amode {

2395

    let v5 = C::def_inst(ctx, arg2);

2396

    if let Some(v6) = v5 {

2397

        let v7 = &C::inst_data(ctx, v6);

2398

        if let &InstructionData::Binary {

2399

            opcode: ref v55,

2400

            args: ref v56,

2401

        } = v7

2402

2403

            if let &Opcode::Iadd = v55 {

2404

                let v57 = C::unpack_value_array_2(ctx, v56);

2405

                let v71 = C::def_inst(ctx, v57.0);

2406

                if let Some(v72) = v71 {

2407

                    let v73 = &C::inst_data(ctx, v72);

2408

                    if let &InstructionData::UnaryImm {

2409

                        opcode: ref v74,

2410

                        imm: v75,

2411

                    } = v73

2412

2413

                        if let &Opcode::Iconst = v74 {

2414

                            let v76 = C::simm32(ctx, v75);

2415

                            if let Some(v77) = v76 {

2416

                                let v12 = C::offset32_to_i32(ctx, arg3);

2417

                                let v78 = C::s32_add_fallible(ctx, v12, v77);

2418

                                if let Some(v79) = v78 {

2419

                                    let v80 = C::i32_to_offset32(ctx, v79);

2420

                                    let v81 = &constructor_amode_imm_reg_reg_shift(

2421

                                        ctx, arg0, arg1, v57.1, v80,

2422

);

2423

                                    // Rule at src/isa/x64/inst.isle line 1116.

2424

                                    return v81.clone();

2425

2426

2427

2428

2429

2430

                let v60 = C::def_inst(ctx, v57.1);

2431

                if let Some(v61) = v60 {

2432

                    let v62 = &C::inst_data(ctx, v61);

2433

                    if let &InstructionData::UnaryImm {

2434

                        opcode: ref v63,

2435

                        imm: v64,

2436

                    } = v62

2437

2438

                        if let &Opcode::Iconst = v63 {

2439

                            let v65 = C::simm32(ctx, v64);

2440

                            if let Some(v66) = v65 {

2441

                                let v12 = C::offset32_to_i32(ctx, arg3);

2442

                                let v67 = C::s32_add_fallible(ctx, v12, v66);

2443

                                if let Some(v68) = v67 {

2444

                                    let v69 = C::i32_to_offset32(ctx, v68);

2445

                                    let v70 = &constructor_amode_imm_reg_reg_shift(

2446

                                        ctx, arg0, arg1, v57.0, v69,

2447

);

2448

                                    // Rule at src/isa/x64/inst.isle line 1113.

2449

                                    return v70.clone();

2450

2451

2452

2453

2454

2455

2456

2457

2458

    let v17 = C::def_inst(ctx, arg1);

2459

    if let Some(v18) = v17 {

2460

        let v19 = &C::inst_data(ctx, v18);

2461

        match v19 {

2462

            &InstructionData::Binary {

2463

                opcode: ref v28,

2464

                args: ref v29,

2465

            } => {

2466

                if let &Opcode::Iadd = v28 {

2467

                    let v30 = C::unpack_value_array_2(ctx, v29);

2468

                    let v44 = C::def_inst(ctx, v30.0);

2469

                    if let Some(v45) = v44 {

2470

                        let v46 = &C::inst_data(ctx, v45);

2471

                        if let &InstructionData::UnaryImm {

2472

                            opcode: ref v47,

2473

                            imm: v48,

2474

                        } = v46

2475

2476

                            if let &Opcode::Iconst = v47 {

2477

                                let v49 = C::simm32(ctx, v48);

2478

                                if let Some(v50) = v49 {

2479

                                    let v12 = C::offset32_to_i32(ctx, arg3);

2480

                                    let v51 = C::s32_add_fallible(ctx, v12, v50);

2481

                                    if let Some(v52) = v51 {

2482

                                        let v53 = C::i32_to_offset32(ctx, v52);

2483

                                        let v54 = &constructor_amode_imm_reg_reg_shift(

2484

                                            ctx, arg0, v30.1, arg2, v53,

2485

);

2486

                                        // Rule at src/isa/x64/inst.isle line 1110.

2487

                                        return v54.clone();

2488

2489

2490

2491

2492

2493

                    let v33 = C::def_inst(ctx, v30.1);

2494

                    if let Some(v34) = v33 {

2495

                        let v35 = &C::inst_data(ctx, v34);

2496

                        if let &InstructionData::UnaryImm {

2497

                            opcode: ref v36,

2498

                            imm: v37,

2499

                        } = v35

2500

2501

                            if let &Opcode::Iconst = v36 {

2502

                                let v38 = C::simm32(ctx, v37);

2503

                                if let Some(v39) = v38 {

2504

                                    let v12 = C::offset32_to_i32(ctx, arg3);

2505

                                    let v40 = C::s32_add_fallible(ctx, v12, v39);

2506

                                    if let Some(v41) = v40 {

2507

                                        let v42 = C::i32_to_offset32(ctx, v41);

2508

                                        let v43 = &constructor_amode_imm_reg_reg_shift(

2509

                                            ctx, arg0, v30.0, arg2, v42,

2510

);

2511

                                        // Rule at src/isa/x64/inst.isle line 1107.

2512

                                        return v43.clone();

2513

2514

2515

2516

2517

2518

2519

2520

            &InstructionData::UnaryImm {

2521

                opcode: ref v20,

2522

                imm: v21,

2523

            } => {

2524

                if let &Opcode::Iconst = v20 {

2525

                    let v22 = C::simm32(ctx, v21);

2526

                    if let Some(v23) = v22 {

2527

                        let v12 = C::offset32_to_i32(ctx, arg3);

2528

                        let v24 = C::s32_add_fallible(ctx, v12, v23);

2529

                        if let Some(v25) = v24 {

2530

                            let v26 = C::i32_to_offset32(ctx, v25);

2531

                            let v27 = &constructor_amode_imm_reg(ctx, arg0, arg2, v26);

2532

                            // Rule at src/isa/x64/inst.isle line 1104.

2533

                            return v27.clone();

2534

2535

2536

2537

2538

            _ => {}

2539

2540

2541

    if let Some(v6) = v5 {

2542

        let v7 = &C::inst_data(ctx, v6);

2543

        if let &InstructionData::UnaryImm {

2544

            opcode: ref v8,

2545

            imm: v9,

2546

        } = v7

2547

2548

            if let &Opcode::Iconst = v8 {

2549

                let v10 = C::simm32(ctx, v9);

2550

                if let Some(v11) = v10 {

2551

                    let v12 = C::offset32_to_i32(ctx, arg3);

2552

                    let v13 = C::s32_add_fallible(ctx, v12, v11);

2553

                    if let Some(v14) = v13 {

2554

                        let v15 = C::i32_to_offset32(ctx, v14);

2555

                        let v16 = &constructor_amode_imm_reg(ctx, arg0, arg1, v15);

2556

                        // Rule at src/isa/x64/inst.isle line 1101.

2557

                        return v16.clone();

2558

2559

2560

2561

2562

2563

    let v4 = &constructor_amode_imm_reg_reg_shift(ctx, arg0, arg1, arg2, arg3);

2564

    // Rule at src/isa/x64/inst.isle line 1099.

2565

    return v4.clone();

2566

2567

2568

// Generated as internal constructor for term amode_imm_reg.

2569

pub fn constructor_amode_imm_reg<C: Context>(

2570

    ctx: &mut C,

2571

    arg0: MemFlags,

2572

    arg1: Value,

2573

    arg2: Offset32,

2574

) -> Amode {

2575

    let v6 = C::def_inst(ctx, arg1);

2576

    if let Some(v7) = v6 {

2577

        let v8 = &C::inst_data(ctx, v7);

2578

        if let &InstructionData::Binary {

2579

            opcode: ref v9,

2580

            args: ref v10,

2581

        } = v8

2582

2583

            if let &Opcode::Iadd = v9 {

2584

                let v11 = C::unpack_value_array_2(ctx, v10);

2585

                let v14 = &constructor_amode_imm_reg_reg_shift(ctx, arg0, v11.0, v11.1, arg2);

2586

                // Rule at src/isa/x64/inst.isle line 1126.

2587

                return v14.clone();

2588

2589

2590

2591

    let v4 = C::put_in_reg(ctx, arg1);

2592

    let v3 = C::offset32_to_i32(ctx, arg2);

2593

    let v5 = Amode::ImmReg {

2594

        simm32: v3,

2595

        base: v4,

2596

        flags: arg0,

2597

};

2598

    // Rule at src/isa/x64/inst.isle line 1124.

2599

    return v5;

2600

2601

2602

// Generated as internal constructor for term amode_imm_reg_reg_shift.

2603

pub fn constructor_amode_imm_reg_reg_shift<C: Context>(

2604

    ctx: &mut C,

2605

    arg0: MemFlags,

2606

    arg1: Value,

2607

    arg2: Value,

2608

    arg3: Offset32,

2609

) -> Amode {

2610

    let v30 = C::def_inst(ctx, arg1);

2611

    if let Some(v31) = v30 {

2612

        let v32 = &C::inst_data(ctx, v31);

2613

        if let &InstructionData::Binary {

2614

            opcode: ref v33,

2615

            args: ref v34,

2616

        } = v32

2617

2618

            if let &Opcode::Ishl = v33 {

2619

                let v35 = C::unpack_value_array_2(ctx, v34);

2620

                let v38 = C::def_inst(ctx, v35.1);

2621

                if let Some(v39) = v38 {

2622

                    let v40 = &C::inst_data(ctx, v39);

2623

                    if let &InstructionData::UnaryImm {

2624

                        opcode: ref v41,

2625

                        imm: v42,

2626

                    } = v40

2627

2628

                        if let &Opcode::Iconst = v41 {

2629

                            let v43 = C::uimm8(ctx, v42);

2630

                            if let Some(v44) = v43 {

2631

                                let v45 = C::u8_as_u32(ctx, v44);

2632

                                let v46 = C::u32_lteq(ctx, v45, 0x3);

2633

                                if let Some(v47) = v46 {

2634

                                    let v48 = constructor_put_in_gpr(ctx, arg2);

2635

                                    let v49 = constructor_put_in_gpr(ctx, v35.0);

2636

                                    let v4 = C::offset32_to_i32(ctx, arg3);

2637

                                    let v50 = Amode::ImmRegRegShift {

2638

                                        simm32: v4,

2639

                                        base: v48,

2640

                                        index: v49,

2641

                                        shift: v44,

2642

                                        flags: arg0,

2643

};

2644

                                    // Rule at src/isa/x64/inst.isle line 1135.

2645

                                    return v50;

2646

2647

2648

2649

2650

2651

2652

2653

2654

    let v9 = C::def_inst(ctx, arg2);

2655

    if let Some(v10) = v9 {

2656

        let v11 = &C::inst_data(ctx, v10);

2657

        if let &InstructionData::Binary {

2658

            opcode: ref v12,

2659

            args: ref v13,

2660

        } = v11

2661

2662

            if let &Opcode::Ishl = v12 {

2663

                let v14 = C::unpack_value_array_2(ctx, v13);

2664

                let v17 = C::def_inst(ctx, v14.1);

2665

                if let Some(v18) = v17 {

2666

                    let v19 = &C::inst_data(ctx, v18);

2667

                    if let &InstructionData::UnaryImm {

2668

                        opcode: ref v20,

2669

                        imm: v21,

2670

                    } = v19

2671

2672

                        if let &Opcode::Iconst = v20 {

2673

                            let v22 = C::uimm8(ctx, v21);

2674

                            if let Some(v23) = v22 {

2675

                                let v24 = C::u8_as_u32(ctx, v23);

2676

                                let v26 = C::u32_lteq(ctx, v24, 0x3);

2677

                                if let Some(v27) = v26 {

2678

                                    let v5 = constructor_put_in_gpr(ctx, arg1);

2679

                                    let v28 = constructor_put_in_gpr(ctx, v14.0);

2680

                                    let v4 = C::offset32_to_i32(ctx, arg3);

2681

                                    let v29 = Amode::ImmRegRegShift {

2682

                                        simm32: v4,

2683

                                        base: v5,

2684

                                        index: v28,

2685

                                        shift: v23,

2686

                                        flags: arg0,

2687

};

2688

                                    // Rule at src/isa/x64/inst.isle line 1132.

2689

                                    return v29;

2690

2691

2692

2693

2694

2695

2696

2697

2698

    let v5 = constructor_put_in_gpr(ctx, arg1);

2699

    let v6 = constructor_put_in_gpr(ctx, arg2);

2700

    let v4 = C::offset32_to_i32(ctx, arg3);

2701

    let v8 = Amode::ImmRegRegShift {

2702

        simm32: v4,

2703

        base: v5,

2704

        index: v6,

2705

        shift: 0x0,

2706

        flags: arg0,

2707

};

2708

    // Rule at src/isa/x64/inst.isle line 1130.

2709

    return v8;

2710

2711

2712

// Generated as internal constructor for term put_masked_in_imm8_gpr.

2713

pub fn constructor_put_masked_in_imm8_gpr<C: Context>(

2714

    ctx: &mut C,

2715

    arg0: Value,

2716

    arg1: Type,

2717

) -> Imm8Gpr {

2718

    let v1 = C::def_inst(ctx, arg0);

2719

    if let Some(v2) = v1 {

2720

        let v3 = &C::inst_data(ctx, v2);

2721

        if let &InstructionData::UnaryImm {

2722

            opcode: ref v4,

2723

            imm: v5,

2724

        } = v3

2725

2726

            if let &Opcode::Iconst = v4 {

2727

                let v6 = C::u64_from_imm64(ctx, v5);

2728

                let v8 = &C::const_to_type_masked_imm8(ctx, v6, arg1);

2729

                // Rule at src/isa/x64/inst.isle line 1171.

2730

                return v8.clone();

2731

2732

2733

2734

    let v9 = C::fits_in_16(ctx, arg1);

2735

    if let Some(v10) = v9 {

2736

        let v12 = C::put_in_regs(ctx, arg0);

2737

        let v14 = constructor_value_regs_get_gpr(ctx, v12, 0x0);

2738

        let v15 = C::shift_mask(ctx, v10);

2739

        let v16 = C::u8_as_u32(ctx, v15);

2740

        let v17 = RegMemImm::Imm { simm32: v16 };

2741

        let v18 = &C::gpr_mem_imm_new(ctx, &v17);

2742

        let v19 = constructor_x64_and(ctx, I64, v14, v18);

2743

        let v20 = &C::gpr_to_imm8_gpr(ctx, v19);

2744

        // Rule at src/isa/x64/inst.isle line 1173.

2745

        return v20.clone();

2746

2747

    let v12 = C::put_in_regs(ctx, arg0);

2748

    let v14 = constructor_value_regs_get_gpr(ctx, v12, 0x0);

2749

    let v21 = &C::gpr_to_imm8_gpr(ctx, v14);

2750

    // Rule at src/isa/x64/inst.isle line 1175.

2751

    return v21.clone();

2752

2753

2754

// Generated as internal constructor for term reg_to_gpr_mem_imm.

2755

pub fn constructor_reg_to_gpr_mem_imm<C: Context>(ctx: &mut C, arg0: Reg) -> GprMemImm {

2756

    let v1 = C::gpr_new(ctx, arg0);

2757

    let v2 = &C::gpr_to_gpr_mem_imm(ctx, v1);

2758

    // Rule at src/isa/x64/inst.isle line 1591.

2759

    return v2.clone();

2760

2761

2762

// Generated as internal constructor for term put_in_gpr.

2763

pub fn constructor_put_in_gpr<C: Context>(ctx: &mut C, arg0: Value) -> Gpr {

2764

    let v1 = C::put_in_reg(ctx, arg0);

2765

    let v2 = C::gpr_new(ctx, v1);

2766

    // Rule at src/isa/x64/inst.isle line 1598.

2767

    return v2;

2768

2769

2770

// Generated as internal constructor for term put_in_gpr_mem.

2771

pub fn constructor_put_in_gpr_mem<C: Context>(ctx: &mut C, arg0: Value) -> GprMem {

2772

    let v1 = &C::put_in_reg_mem(ctx, arg0);

2773

    let v2 = &C::reg_mem_to_gpr_mem(ctx, v1);

2774

    // Rule at src/isa/x64/inst.isle line 1605.

2775

    return v2.clone();

2776

2777

2778

// Generated as internal constructor for term put_in_gpr_mem_imm.

2779

pub fn constructor_put_in_gpr_mem_imm<C: Context>(ctx: &mut C, arg0: Value) -> GprMemImm {

2780

    let v1 = &C::put_in_reg_mem_imm(ctx, arg0);

2781

    let v2 = &C::gpr_mem_imm_new(ctx, v1);

2782

    // Rule at src/isa/x64/inst.isle line 1612.

2783

    return v2.clone();

2784

2785

2786

// Generated as internal constructor for term put_in_xmm.

2787

pub fn constructor_put_in_xmm<C: Context>(ctx: &mut C, arg0: Value) -> Xmm {

2788

    let v1 = C::put_in_reg(ctx, arg0);

2789

    let v2 = C::xmm_new(ctx, v1);

2790

    // Rule at src/isa/x64/inst.isle line 1619.

2791

    return v2;

2792

2793

2794

// Generated as internal constructor for term output_gpr.

2795

pub fn constructor_output_gpr<C: Context>(ctx: &mut C, arg0: Gpr) -> InstOutput {

2796

    let v1 = C::gpr_to_reg(ctx, arg0);

2797

    let v2 = constructor_output_reg(ctx, v1);

2798

    // Rule at src/isa/x64/inst.isle line 1636.

2799

    return v2;

2800

2801

2802

// Generated as internal constructor for term value_gprs.

2803

pub fn constructor_value_gprs<C: Context>(ctx: &mut C, arg0: Gpr, arg1: Gpr) -> ValueRegs {

2804

    let v2 = C::gpr_to_reg(ctx, arg0);

2805

    let v3 = C::gpr_to_reg(ctx, arg1);

2806

    let v4 = C::value_regs(ctx, v2, v3);

2807

    // Rule at src/isa/x64/inst.isle line 1641.

2808

    return v4;

2809

2810

2811

// Generated as internal constructor for term output_xmm.

2812

pub fn constructor_output_xmm<C: Context>(ctx: &mut C, arg0: Xmm) -> InstOutput {

2813

    let v1 = C::xmm_to_reg(ctx, arg0);

2814

    let v2 = constructor_output_reg(ctx, v1);

2815

    // Rule at src/isa/x64/inst.isle line 1646.

2816

    return v2;

2817

2818

2819

// Generated as internal constructor for term value_regs_get_gpr.

2820

pub fn constructor_value_regs_get_gpr<C: Context>(

2821

    ctx: &mut C,

2822

    arg0: ValueRegs,

2823

    arg1: usize,

2824

) -> Gpr {

2825

    let v2 = C::value_regs_get(ctx, arg0, arg1);

2826

    let v3 = C::gpr_new(ctx, v2);

2827

    // Rule at src/isa/x64/inst.isle line 1653.

2828

    return v3;

2829

2830

2831

// Generated as internal constructor for term lo_gpr.

2832

pub fn constructor_lo_gpr<C: Context>(ctx: &mut C, arg0: Value) -> Gpr {

2833

    let v1 = constructor_lo_reg(ctx, arg0);

2834

    let v2 = C::gpr_new(ctx, v1);

2835

    // Rule at src/isa/x64/inst.isle line 1666.

2836

    return v2;

2837

2838

2839

// Generated as internal constructor for term sink_load_to_gpr_mem_imm.

2840

pub fn constructor_sink_load_to_gpr_mem_imm<C: Context>(

2841

    ctx: &mut C,

2842

    arg0: &SinkableLoad,

2843

) -> GprMemImm {

2844

    let v1 = &constructor_sink_load_to_reg_mem_imm(ctx, arg0);

2845

    let v2 = &C::gpr_mem_imm_new(ctx, v1);

2846

    // Rule at src/isa/x64/inst.isle line 1801.

2847

    return v2.clone();

2848

2849

2850

// Generated as internal constructor for term sink_load_to_xmm_mem.

2851

pub fn constructor_sink_load_to_xmm_mem<C: Context>(ctx: &mut C, arg0: &SinkableLoad) -> XmmMem {

2852

    let v1 = &constructor_sink_load_to_reg_mem(ctx, arg0);

2853

    let v2 = &C::reg_mem_to_xmm_mem(ctx, v1);

2854

    // Rule at src/isa/x64/inst.isle line 1805.

2855

    return v2.clone();

2856

2857

2858

// Generated as internal constructor for term sink_load_to_reg_mem.

2859

pub fn constructor_sink_load_to_reg_mem<C: Context>(ctx: &mut C, arg0: &SinkableLoad) -> RegMem {

2860

    let v1 = &C::sink_load(ctx, arg0);

2861

    let v2 = RegMem::Mem { addr: v1.clone() };

2862

    // Rule at src/isa/x64/inst.isle line 1809.

2863

    return v2;

2864

2865

2866

// Generated as internal constructor for term sink_load_to_gpr_mem.

2867

pub fn constructor_sink_load_to_gpr_mem<C: Context>(ctx: &mut C, arg0: &SinkableLoad) -> GprMem {

2868

    let v1 = &C::sink_load(ctx, arg0);

2869

    let v2 = RegMem::Mem { addr: v1.clone() };

2870

    let v3 = &C::reg_mem_to_gpr_mem(ctx, &v2);

2871

    // Rule at src/isa/x64/inst.isle line 1812.

2872

    return v3.clone();

2873

2874

2875

// Generated as internal constructor for term sink_load_to_reg_mem_imm.

2876

pub fn constructor_sink_load_to_reg_mem_imm<C: Context>(

2877

    ctx: &mut C,

2878

    arg0: &SinkableLoad,

2879

) -> RegMemImm {

2880

    let v1 = &C::sink_load(ctx, arg0);

2881

    let v2 = RegMemImm::Mem { addr: v1.clone() };

2882

    // Rule at src/isa/x64/inst.isle line 1815.

2883

    return v2;

2884

2885

2886

// Generated as internal constructor for term xmm_uninit_value.

2887

pub fn constructor_xmm_uninit_value<C: Context>(ctx: &mut C) -> Xmm {

2888

    let v0 = C::temp_writable_xmm(ctx);

2889

    let v1 = MInst::XmmUninitializedValue { dst: v0 };

2890

    let v2 = C::emit(ctx, &v1);

2891

    let v3 = C::writable_xmm_to_xmm(ctx, v0);

2892

    // Rule at src/isa/x64/inst.isle line 1827.

2893

    return v3;

2894

2895

2896

// Generated as internal constructor for term load_ext_name.

2897

pub fn constructor_load_ext_name<C: Context>(

2898

    ctx: &mut C,

2899

    arg0: ExternalName,

2900

    arg1: i64,

2901

    arg2: RelocDistance,

2902

) -> Reg {

2903

    let v3 = C::temp_writable_gpr(ctx);

2904

    let v4 = C::writable_gpr_to_reg(ctx, v3);

2905

    let v5 = C::box_external_name(ctx, arg0);

2906

    let v6 = MInst::LoadExtName {

2907

        dst: v4,

2908

        name: v5,

2909

        offset: arg1,

2910

        distance: arg2,

2911

};

2912

    let v7 = C::emit(ctx, &v6);

2913

    let v8 = constructor_writable_gpr_to_r_reg(ctx, v3);

2914

    // Rule at src/isa/x64/inst.isle line 1834.

2915

    return v8;

2916

2917

2918

// Generated as internal constructor for term mov64_mr.

2919

pub fn constructor_mov64_mr<C: Context>(ctx: &mut C, arg0: &SyntheticAmode) -> Reg {

2920

    let v1 = C::temp_writable_gpr(ctx);

2921

    let v2 = MInst::Mov64MR {

2922

        src: arg0.clone(),

2923

        dst: v1,

2924

};

2925

    let v3 = C::emit(ctx, &v2);

2926

    let v4 = constructor_writable_gpr_to_r_reg(ctx, v1);

2927

    // Rule at src/isa/x64/inst.isle line 1841.

2928

    return v4;

2929

2930

2931

// Generated as internal constructor for term alu_rmi_r.

2932

pub fn constructor_alu_rmi_r<C: Context>(

2933

    ctx: &mut C,

2934

    arg0: Type,

2935

    arg1: &AluRmiROpcode,

2936

    arg2: Gpr,

2937

    arg3: &GprMemImm,

2938

) -> Gpr {

2939

    let v4 = C::temp_writable_gpr(ctx);

2940

    let v5 = &C::operand_size_of_type_32_64(ctx, arg0);

2941

    let v6 = MInst::AluRmiR {

2942

        size: v5.clone(),

2943

        op: arg1.clone(),

2944

        src1: arg2,

2945

        src2: arg3.clone(),

2946

        dst: v4,

2947

};

2948

    let v7 = C::emit(ctx, &v6);

2949

    let v8 = C::writable_gpr_to_gpr(ctx, v4);

2950

    // Rule at src/isa/x64/inst.isle line 1848.

2951

    return v8;

2952

2953

2954

// Generated as internal constructor for term alu_rm_r_vex.

2955

pub fn constructor_alu_rm_r_vex<C: Context>(

2956

    ctx: &mut C,

2957

    arg0: Type,

2958

    arg1: &AluRmROpcode,

2959

    arg2: Gpr,

2960

    arg3: &GprMem,

2961

) -> Gpr {

2962

    let v4 = C::temp_writable_gpr(ctx);

2963

    let v5 = &C::operand_size_of_type_32_64(ctx, arg0);

2964

    let v6 = MInst::AluRmRVex {

2965

        size: v5.clone(),

2966

        op: arg1.clone(),

2967

        src1: arg2,

2968

        src2: arg3.clone(),

2969

        dst: v4,

2970

};

2971

    let v7 = C::emit(ctx, &v6);

2972

    let v8 = C::writable_gpr_to_gpr(ctx, v4);

2973

    // Rule at src/isa/x64/inst.isle line 1856.

2974

    return v8;

2975

2976

2977

// Generated as internal constructor for term xmm_rm_r.

2978

pub fn constructor_xmm_rm_r<C: Context>(

2979

    ctx: &mut C,

2980

    arg0: &SseOpcode,

2981

    arg1: Xmm,

2982

    arg2: &XmmMemAligned,

2983

) -> Xmm {

2984

    let v3 = C::temp_writable_xmm(ctx);

2985

    let v4 = MInst::XmmRmR {

2986

        op: arg0.clone(),

2987

        src1: arg1,

2988

        src2: arg2.clone(),

2989

        dst: v3,

2990

};

2991

    let v5 = C::emit(ctx, &v4);

2992

    let v6 = C::writable_xmm_to_xmm(ctx, v3);

2993

    // Rule at src/isa/x64/inst.isle line 1864.

2994

    return v6;

2995

2996

2997

// Generated as internal constructor for term xmm_rm_r_unaligned.

2998

pub fn constructor_xmm_rm_r_unaligned<C: Context>(

2999

    ctx: &mut C,

3000

    arg0: &SseOpcode,

3001

    arg1: Xmm,

3002

    arg2: &XmmMem,

3003

) -> Xmm {

3004

    let v3 = C::temp_writable_xmm(ctx);

3005

    let v4 = MInst::XmmRmRUnaligned {

3006

        op: arg0.clone(),

3007

        src1: arg1,

3008

        src2: arg2.clone(),

3009

        dst: v3,

3010

};

3011

    let v5 = C::emit(ctx, &v4);

3012

    let v6 = C::writable_xmm_to_xmm(ctx, v3);

3013

    // Rule at src/isa/x64/inst.isle line 1871.

3014

    return v6;

3015

3016

3017

// Generated as internal constructor for term xmm_rm_r_blend.

3018

pub fn constructor_xmm_rm_r_blend<C: Context>(

3019

    ctx: &mut C,

3020

    arg0: &SseOpcode,

3021

    arg1: Xmm,

3022

    arg2: &XmmMemAligned,

3023

    arg3: Xmm,

3024

) -> Xmm {

3025

    let v4 = C::temp_writable_xmm(ctx);

3026

    let v5 = MInst::XmmRmRBlend {

3027

        op: arg0.clone(),

3028

        src1: arg1,

3029

        src2: arg2.clone(),

3030

        mask: arg3,

3031

        dst: v4,

3032

};

3033

    let v6 = C::emit(ctx, &v5);

3034

    let v7 = C::writable_xmm_to_xmm(ctx, v4);

3035

    // Rule at src/isa/x64/inst.isle line 1878.

3036

    return v7;

3037

3038

3039

// Generated as internal constructor for term xmm_rmr_blend_vex.

3040

pub fn constructor_xmm_rmr_blend_vex<C: Context>(

3041

    ctx: &mut C,

3042

    arg0: &AvxOpcode,

3043

    arg1: Xmm,

3044

    arg2: &XmmMem,

3045

    arg3: Xmm,

3046

) -> Xmm {

3047

    let v4 = C::temp_writable_xmm(ctx);

3048

    let v5 = MInst::XmmRmRBlendVex {

3049

        op: arg0.clone(),

3050

        src1: arg1,

3051

        src2: arg2.clone(),

3052

        mask: arg3,

3053

        dst: v4,

3054

};

3055

    let v6 = C::emit(ctx, &v5);

3056

    let v7 = C::writable_xmm_to_xmm(ctx, v4);

3057

    // Rule at src/isa/x64/inst.isle line 1885.

3058

    return v7;

3059

3060

3061

// Generated as internal constructor for term xmm_unary_rm_r_vex.

3062

pub fn constructor_xmm_unary_rm_r_vex<C: Context>(

3063

    ctx: &mut C,

3064

    arg0: &AvxOpcode,

3065

    arg1: &XmmMem,

3066

) -> Xmm {

3067

    let v2 = C::temp_writable_xmm(ctx);

3068

    let v3 = MInst::XmmUnaryRmRVex {

3069

        op: arg0.clone(),

3070

        src: arg1.clone(),

3071

        dst: v2,

3072

};

3073

    let v4 = C::emit(ctx, &v3);

3074

    let v5 = C::writable_xmm_to_xmm(ctx, v2);

3075

    // Rule at src/isa/x64/inst.isle line 1892.

3076

    return v5;

3077

3078

3079

// Generated as internal constructor for term xmm_unary_rm_r_imm_vex.

3080

pub fn constructor_xmm_unary_rm_r_imm_vex<C: Context>(

3081

    ctx: &mut C,

3082

    arg0: &AvxOpcode,

3083

    arg1: &XmmMem,

3084

    arg2: u8,

3085

) -> Xmm {

3086

    let v3 = C::temp_writable_xmm(ctx);

3087

    let v4 = MInst::XmmUnaryRmRImmVex {

3088

        op: arg0.clone(),

3089

        src: arg1.clone(),

3090

        dst: v3,

3091

        imm: arg2,

3092

};

3093

    let v5 = C::emit(ctx, &v4);

3094

    let v6 = C::writable_xmm_to_xmm(ctx, v3);

3095

    // Rule at src/isa/x64/inst.isle line 1899.

3096

    return v6;

3097

3098

3099

// Generated as internal constructor for term xmm_rm_r_imm.

3100

pub fn constructor_xmm_rm_r_imm<C: Context>(

3101

    ctx: &mut C,

3102

    arg0: &SseOpcode,

3103

    arg1: Reg,

3104

    arg2: &RegMem,

3105

    arg3: u8,

3106

    arg4: &OperandSize,

3107

) -> Xmm {

3108

    let v5 = C::temp_writable_xmm(ctx);

3109

    let v6 = C::writable_xmm_to_reg(ctx, v5);

3110

    let v7 = MInst::XmmRmRImm {

3111

        op: arg0.clone(),

3112

        src1: arg1,

3113

        src2: arg2.clone(),

3114

        dst: v6,

3115

        imm: arg3,

3116

        size: arg4.clone(),

3117

};

3118

    let v8 = C::emit(ctx, &v7);

3119

    let v9 = C::writable_xmm_to_xmm(ctx, v5);

3120

    // Rule at src/isa/x64/inst.isle line 1906.

3121

    return v9;

3122

3123

3124

// Generated as internal constructor for term xmm_vex_pinsr.

3125

pub fn constructor_xmm_vex_pinsr<C: Context>(

3126

    ctx: &mut C,

3127

    arg0: &AvxOpcode,

3128

    arg1: Xmm,

3129

    arg2: &GprMem,

3130

    arg3: u8,

3131

) -> Xmm {

3132

    let v4 = C::temp_writable_xmm(ctx);

3133

    let v5 = MInst::XmmVexPinsr {

3134

        op: arg0.clone(),

3135

        src1: arg1,

3136

        src2: arg2.clone(),

3137

        dst: v4,

3138

        imm: arg3,

3139

};

3140

    let v6 = C::emit(ctx, &v5);

3141

    let v7 = C::writable_xmm_to_xmm(ctx, v4);

3142

    // Rule at src/isa/x64/inst.isle line 1918.

3143

    return v7;

3144

3145

3146

// Generated as internal constructor for term xmm_unary_rm_r_imm.

3147

pub fn constructor_xmm_unary_rm_r_imm<C: Context>(

3148

    ctx: &mut C,

3149

    arg0: &SseOpcode,

3150

    arg1: &XmmMemAligned,

3151

    arg2: u8,

3152

) -> Xmm {

3153

    let v3 = C::temp_writable_xmm(ctx);

3154

    let v4 = MInst::XmmUnaryRmRImm {

3155

        op: arg0.clone(),

3156

        src: arg1.clone(),

3157

        imm: arg2,

3158

        dst: v3,

3159

};

3160

    let v5 = C::emit(ctx, &v4);

3161

    let v6 = C::writable_xmm_to_xmm(ctx, v3);

3162

    // Rule at src/isa/x64/inst.isle line 1925.

3163

    return v6;

3164

3165

3166

// Generated as internal constructor for term xmm_unary_rm_r.

3167

pub fn constructor_xmm_unary_rm_r<C: Context>(

3168

    ctx: &mut C,

3169

    arg0: &SseOpcode,

3170

    arg1: &XmmMemAligned,

3171

) -> Xmm {

3172

    let v2 = C::temp_writable_xmm(ctx);

3173

    let v3 = MInst::XmmUnaryRmR {

3174

        op: arg0.clone(),

3175

        src: arg1.clone(),

3176

        dst: v2,

3177

};

3178

    let v4 = C::emit(ctx, &v3);

3179

    let v5 = C::writable_xmm_to_xmm(ctx, v2);

3180

    // Rule at src/isa/x64/inst.isle line 1932.

3181

    return v5;

3182

3183

3184

// Generated as internal constructor for term xmm_unary_rm_r_unaligned.

3185

pub fn constructor_xmm_unary_rm_r_unaligned<C: Context>(

3186

    ctx: &mut C,

3187

    arg0: &SseOpcode,

3188

    arg1: &XmmMem,

3189

) -> Xmm {

3190

    let v2 = C::temp_writable_xmm(ctx);

3191

    let v3 = MInst::XmmUnaryRmRUnaligned {

3192

        op: arg0.clone(),

3193

        src: arg1.clone(),

3194

        dst: v2,

3195

};

3196

    let v4 = C::emit(ctx, &v3);

3197

    let v5 = C::writable_xmm_to_xmm(ctx, v2);

3198

    // Rule at src/isa/x64/inst.isle line 1939.

3199

    return v5;

3200

3201

3202

// Generated as internal constructor for term xmm_unary_rm_r_evex.

3203

pub fn constructor_xmm_unary_rm_r_evex<C: Context>(

3204

    ctx: &mut C,

3205

    arg0: &Avx512Opcode,

3206

    arg1: &XmmMem,

3207

) -> Xmm {

3208

    let v2 = C::temp_writable_xmm(ctx);

3209

    let v3 = MInst::XmmUnaryRmREvex {

3210

        op: arg0.clone(),

3211

        src: arg1.clone(),

3212

        dst: v2,

3213

};

3214

    let v4 = C::emit(ctx, &v3);

3215

    let v5 = C::writable_xmm_to_xmm(ctx, v2);

3216

    // Rule at src/isa/x64/inst.isle line 1946.

3217

    return v5;

3218

3219

3220

// Generated as internal constructor for term xmm_rm_r_evex.

3221

pub fn constructor_xmm_rm_r_evex<C: Context>(

3222

    ctx: &mut C,

3223

    arg0: &Avx512Opcode,

3224

    arg1: Xmm,

3225

    arg2: &XmmMem,

3226

) -> Xmm {

3227

    let v3 = C::temp_writable_xmm(ctx);

3228

    let v4 = MInst::XmmRmREvex {

3229

        op: arg0.clone(),

3230

        src1: arg1,

3231

        src2: arg2.clone(),

3232

        dst: v3,

3233

};

3234

    let v5 = C::emit(ctx, &v4);

3235

    let v6 = C::writable_xmm_to_xmm(ctx, v3);

3236

    // Rule at src/isa/x64/inst.isle line 1953.

3237

    return v6;

3238

3239

3240

// Generated as internal constructor for term xmm_unary_rm_r_imm_evex.

3241

pub fn constructor_xmm_unary_rm_r_imm_evex<C: Context>(

3242

    ctx: &mut C,

3243

    arg0: &Avx512Opcode,

3244

    arg1: &XmmMem,

3245

    arg2: u8,

3246

) -> Xmm {

3247

    let v3 = C::temp_writable_xmm(ctx);

3248

    let v4 = MInst::XmmUnaryRmRImmEvex {

3249

        op: arg0.clone(),

3250

        src: arg1.clone(),

3251

        dst: v3,

3252

        imm: arg2,

3253

};

3254

    let v5 = C::emit(ctx, &v4);

3255

    let v6 = C::writable_xmm_to_xmm(ctx, v3);

3256

    // Rule at src/isa/x64/inst.isle line 1963.

3257

    return v6;

3258

3259

3260

// Generated as internal constructor for term xmm_rmi_xmm.

3261

pub fn constructor_xmm_rmi_xmm<C: Context>(

3262

    ctx: &mut C,

3263

    arg0: &SseOpcode,

3264

    arg1: Xmm,

3265

    arg2: &XmmMemAlignedImm,

3266

) -> Xmm {

3267

    let v3 = C::temp_writable_xmm(ctx);

3268

    let v4 = MInst::XmmRmiReg {

3269

        opcode: arg0.clone(),

3270

        src1: arg1,

3271

        src2: arg2.clone(),

3272

        dst: v3,

3273

};

3274

    let v5 = C::emit(ctx, &v4);

3275

    let v6 = C::writable_xmm_to_xmm(ctx, v3);

3276

    // Rule at src/isa/x64/inst.isle line 1970.

3277

    return v6;

3278

3279

3280

// Generated as internal constructor for term xmm_to_gpr_imm.

3281

pub fn constructor_xmm_to_gpr_imm<C: Context>(

3282

    ctx: &mut C,

3283

    arg0: &SseOpcode,

3284

    arg1: Xmm,

3285

    arg2: u8,

3286

) -> Gpr {

3287

    let v3 = C::temp_writable_gpr(ctx);

3288

    let v4 = MInst::XmmToGprImm {

3289

        op: arg0.clone(),

3290

        src: arg1,

3291

        dst: v3,

3292

        imm: arg2,

3293

};

3294

    let v5 = C::emit(ctx, &v4);

3295

    let v6 = C::writable_gpr_to_gpr(ctx, v3);

3296

    // Rule at src/isa/x64/inst.isle line 1980.

3297

    return v6;

3298

3299

3300

// Generated as internal constructor for term xmm_to_gpr_imm_vex.

3301

pub fn constructor_xmm_to_gpr_imm_vex<C: Context>(

3302

    ctx: &mut C,

3303

    arg0: &AvxOpcode,

3304

    arg1: Xmm,

3305

    arg2: u8,

3306

) -> Gpr {

3307

    let v3 = C::temp_writable_gpr(ctx);

3308

    let v4 = MInst::XmmToGprImmVex {

3309

        op: arg0.clone(),

3310

        src: arg1,

3311

        dst: v3,

3312

        imm: arg2,

3313

};

3314

    let v5 = C::emit(ctx, &v4);

3315

    let v6 = C::writable_gpr_to_gpr(ctx, v3);

3316

    // Rule at src/isa/x64/inst.isle line 1987.

3317

    return v6;

3318

3319

3320

// Generated as internal constructor for term gpr_to_xmm.

3321

pub fn constructor_gpr_to_xmm<C: Context>(

3322

    ctx: &mut C,

3323

    arg0: &SseOpcode,

3324

    arg1: &GprMem,

3325

    arg2: &OperandSize,

3326

) -> Xmm {

3327

    let v3 = C::temp_writable_xmm(ctx);

3328

    let v4 = MInst::GprToXmm {

3329

        op: arg0.clone(),

3330

        src: arg1.clone(),

3331

        dst: v3,

3332

        src_size: arg2.clone(),

3333

};

3334

    let v5 = C::emit(ctx, &v4);

3335

    let v6 = C::writable_xmm_to_xmm(ctx, v3);

3336

    // Rule at src/isa/x64/inst.isle line 1994.

3337

    return v6;

3338

3339

3340

// Generated as internal constructor for term gpr_to_xmm_vex.

3341

pub fn constructor_gpr_to_xmm_vex<C: Context>(

3342

    ctx: &mut C,

3343

    arg0: &AvxOpcode,

3344

    arg1: &GprMem,

3345

    arg2: &OperandSize,

3346

) -> Xmm {

3347

    let v3 = C::temp_writable_xmm(ctx);

3348

    let v4 = MInst::GprToXmmVex {

3349

        op: arg0.clone(),

3350

        src: arg1.clone(),

3351

        dst: v3,

3352

        src_size: arg2.clone(),

3353

};

3354

    let v5 = C::emit(ctx, &v4);

3355

    let v6 = C::writable_xmm_to_xmm(ctx, v3);

3356

    // Rule at src/isa/x64/inst.isle line 2001.

3357

    return v6;

3358

3359

3360

// Generated as internal constructor for term xmm_to_gpr.

3361

pub fn constructor_xmm_to_gpr<C: Context>(

3362

    ctx: &mut C,

3363

    arg0: &SseOpcode,

3364

    arg1: Xmm,

3365

    arg2: &OperandSize,

3366

) -> Gpr {

3367

    let v3 = C::temp_writable_gpr(ctx);

3368

    let v4 = MInst::XmmToGpr {

3369

        op: arg0.clone(),

3370

        src: arg1,

3371

        dst: v3,

3372

        dst_size: arg2.clone(),

3373

};

3374

    let v5 = C::emit(ctx, &v4);

3375

    let v6 = C::writable_gpr_to_gpr(ctx, v3);

3376

    // Rule at src/isa/x64/inst.isle line 2008.

3377

    return v6;

3378

3379

3380

// Generated as internal constructor for term xmm_to_gpr_vex.

3381

pub fn constructor_xmm_to_gpr_vex<C: Context>(

3382

    ctx: &mut C,

3383

    arg0: &AvxOpcode,

3384

    arg1: Xmm,

3385

    arg2: &OperandSize,

3386

) -> Gpr {

3387

    let v3 = C::temp_writable_gpr(ctx);

3388

    let v4 = MInst::XmmToGprVex {

3389

        op: arg0.clone(),

3390

        src: arg1,

3391

        dst: v3,

3392

        dst_size: arg2.clone(),

3393

};

3394

    let v5 = C::emit(ctx, &v4);

3395

    let v6 = C::writable_gpr_to_gpr(ctx, v3);

3396

    // Rule at src/isa/x64/inst.isle line 2015.

3397

    return v6;

3398

3399

3400

// Generated as internal constructor for term xmm_min_max_seq.

3401

pub fn constructor_xmm_min_max_seq<C: Context>(

3402

    ctx: &mut C,

3403

    arg0: Type,

3404

    arg1: bool,

3405

    arg2: Xmm,

3406

    arg3: Xmm,

3407

) -> Xmm {

3408

    let v4 = C::temp_writable_xmm(ctx);

3409

    let v5 = &C::operand_size_of_type_32_64(ctx, arg0);

3410

    let v6 = MInst::XmmMinMaxSeq {

3411

        size: v5.clone(),

3412

        is_min: arg1,

3413

        lhs: arg2,

3414

        rhs: arg3,

3415

        dst: v4,

3416

};

3417

    let v7 = C::emit(ctx, &v6);

3418

    let v8 = C::writable_xmm_to_xmm(ctx, v4);

3419

    // Rule at src/isa/x64/inst.isle line 2022.

3420

    return v8;

3421

3422

3423

// Generated as internal constructor for term xmm_rmir_vex.

3424

pub fn constructor_xmm_rmir_vex<C: Context>(

3425

    ctx: &mut C,

3426

    arg0: &AvxOpcode,

3427

    arg1: Xmm,

3428

    arg2: &XmmMemImm,

3429

) -> Xmm {

3430

    let v3 = C::temp_writable_xmm(ctx);

3431

    let v4 = MInst::XmmRmiRVex {

3432

        op: arg0.clone(),

3433

        src1: arg1,

3434

        src2: arg2.clone(),

3435

        dst: v3,

3436

};

3437

    let v5 = C::emit(ctx, &v4);

3438

    let v6 = C::writable_xmm_to_xmm(ctx, v3);

3439

    // Rule at src/isa/x64/inst.isle line 2030.

3440

    return v6;

3441

3442

3443

// Generated as internal constructor for term xmm_rmr_imm_vex.

3444

pub fn constructor_xmm_rmr_imm_vex<C: Context>(

3445

    ctx: &mut C,

3446

    arg0: &AvxOpcode,

3447

    arg1: Xmm,

3448

    arg2: &XmmMem,

3449

    arg3: u8,

3450

) -> Xmm {

3451

    let v4 = C::temp_writable_xmm(ctx);

3452

    let v5 = MInst::XmmRmRImmVex {

3453

        op: arg0.clone(),

3454

        src1: arg1,

3455

        src2: arg2.clone(),

3456

        dst: v4,

3457

        imm: arg3,

3458

};

3459

    let v6 = C::emit(ctx, &v5);

3460

    let v7 = C::writable_xmm_to_xmm(ctx, v4);

3461

    // Rule at src/isa/x64/inst.isle line 2037.

3462

    return v7;

3463

3464

3465

// Generated as internal constructor for term xmm_rmr_vex3.

3466

pub fn constructor_xmm_rmr_vex3<C: Context>(

3467

    ctx: &mut C,

3468

    arg0: &AvxOpcode,

3469

    arg1: Xmm,

3470

    arg2: Xmm,

3471

    arg3: &XmmMem,

3472

) -> Xmm {

3473

    let v4 = C::temp_writable_xmm(ctx);

3474

    let v5 = MInst::XmmRmRVex3 {

3475

        op: arg0.clone(),

3476

        src1: arg1,

3477

        src2: arg2,

3478

        src3: arg3.clone(),

3479

        dst: v4,

3480

};

3481

    let v6 = C::emit(ctx, &v5);

3482

    let v7 = C::writable_xmm_to_xmm(ctx, v4);

3483

    // Rule at src/isa/x64/inst.isle line 2044.

3484

    return v7;

3485

3486

3487

// Generated as internal constructor for term mul_hi.

3488

pub fn constructor_mul_hi<C: Context>(

3489

    ctx: &mut C,

3490

    arg0: Type,

3491

    arg1: bool,

3492

    arg2: Gpr,

3493

    arg3: &GprMem,

3494

) -> ValueRegs {

3495

    let v4 = C::temp_writable_gpr(ctx);

3496

    let v5 = C::temp_writable_gpr(ctx);

3497

    let v6 = &C::raw_operand_size_of_type(ctx, arg0);

3498

    let v7 = MInst::MulHi {

3499

        size: v6.clone(),

3500

        signed: arg1,

3501

        src1: arg2,

3502

        src2: arg3.clone(),

3503

        dst_lo: v4,

3504

        dst_hi: v5,

3505

};

3506

    let v8 = C::emit(ctx, &v7);

3507

    let v9 = C::writable_gpr_to_gpr(ctx, v4);

3508

    let v10 = C::writable_gpr_to_gpr(ctx, v5);

3509

    let v11 = constructor_value_gprs(ctx, v9, v10);

3510

    // Rule at src/isa/x64/inst.isle line 2053.

3511

    return v11;

3512

3513

3514

// Generated as internal constructor for term unary_rm_r.

3515

pub fn constructor_unary_rm_r<C: Context>(

3516

    ctx: &mut C,

3517

    arg0: &UnaryRmROpcode,

3518

    arg1: Gpr,

3519

    arg2: &OperandSize,

3520

) -> Gpr {

3521

    let v3 = C::temp_writable_gpr(ctx);

3522

    let v4 = &C::gpr_to_gpr_mem(ctx, arg1);

3523

    let v5 = MInst::UnaryRmR {

3524

        size: arg2.clone(),

3525

        op: arg0.clone(),

3526

        src: v4.clone(),

3527

        dst: v3,

3528

};

3529

    let v6 = C::emit(ctx, &v5);

3530

    let v7 = C::writable_gpr_to_gpr(ctx, v3);

3531

    // Rule at src/isa/x64/inst.isle line 2067.

3532

    return v7;

3533

3534

3535

// Generated as internal constructor for term unary_rm_r_vex.

3536

pub fn constructor_unary_rm_r_vex<C: Context>(

3537

    ctx: &mut C,

3538

    arg0: &UnaryRmRVexOpcode,

3539

    arg1: &GprMem,

3540

    arg2: &OperandSize,

3541

) -> Gpr {

3542

    let v3 = C::temp_writable_gpr(ctx);

3543

    let v4 = MInst::UnaryRmRVex {

3544

        size: arg2.clone(),

3545

        op: arg0.clone(),

3546

        src: arg1.clone(),

3547

        dst: v3,

3548

};

3549

    let v5 = C::emit(ctx, &v4);

3550

    let v6 = C::writable_gpr_to_gpr(ctx, v3);

3551

    // Rule at src/isa/x64/inst.isle line 2074.

3552

    return v6;

3553

3554

3555

// Generated as internal constructor for term unary_rm_r_imm_vex.

3556

pub fn constructor_unary_rm_r_imm_vex<C: Context>(

3557

    ctx: &mut C,

3558

    arg0: &UnaryRmRImmVexOpcode,

3559

    arg1: &GprMem,

3560

    arg2: &OperandSize,

3561

    arg3: u8,

3562

) -> Gpr {

3563

    let v4 = C::temp_writable_gpr(ctx);

3564

    let v5 = MInst::UnaryRmRImmVex {

3565

        size: arg2.clone(),

3566

        op: arg0.clone(),

3567

        src: arg1.clone(),

3568

        dst: v4,

3569

        imm: arg3,

3570

};

3571

    let v6 = C::emit(ctx, &v5);

3572

    let v7 = C::writable_gpr_to_gpr(ctx, v4);

3573

    // Rule at src/isa/x64/inst.isle line 2081.

3574

    return v7;

3575

3576

3577

// Generated as internal constructor for term cvt_int_to_float.

3578

pub fn constructor_cvt_int_to_float<C: Context>(

3579

    ctx: &mut C,

3580

    arg0: &SseOpcode,

3581

    arg1: Xmm,

3582

    arg2: &GprMem,

3583

    arg3: &OperandSize,

3584

) -> Xmm {

3585

    let v4 = C::temp_writable_xmm(ctx);

3586

    let v5 = MInst::CvtIntToFloat {

3587

        op: arg0.clone(),

3588

        src1: arg1,

3589

        src2: arg2.clone(),

3590

        dst: v4,

3591

        src2_size: arg3.clone(),

3592

};

3593

    let v6 = C::emit(ctx, &v5);

3594

    let v7 = C::writable_xmm_to_xmm(ctx, v4);

3595

    // Rule at src/isa/x64/inst.isle line 2087.

3596

    return v7;

3597

3598

3599

// Generated as internal constructor for term cvt_int_to_float_vex.

3600

pub fn constructor_cvt_int_to_float_vex<C: Context>(

3601

    ctx: &mut C,

3602

    arg0: &AvxOpcode,

3603

    arg1: Xmm,

3604

    arg2: &GprMem,

3605

    arg3: &OperandSize,

3606

) -> Xmm {

3607

    let v4 = C::temp_writable_xmm(ctx);

3608

    let v5 = MInst::CvtIntToFloatVex {

3609

        op: arg0.clone(),

3610

        src1: arg1,

3611

        src2: arg2.clone(),

3612

        dst: v4,

3613

        src2_size: arg3.clone(),

3614

};

3615

    let v6 = C::emit(ctx, &v5);

3616

    let v7 = C::writable_xmm_to_xmm(ctx, v4);

3617

    // Rule at src/isa/x64/inst.isle line 2093.

3618

    return v7;

3619

3620

3621

// Generated as internal constructor for term cvt_u64_to_float_seq.

3622

pub fn constructor_cvt_u64_to_float_seq<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Xmm {

3623

    let v2 = &C::raw_operand_size_of_type(ctx, arg0);

3624

    let v3 = C::temp_writable_xmm(ctx);

3625

    let v4 = C::temp_writable_gpr(ctx);

3626

    let v5 = C::temp_writable_gpr(ctx);

3627

    let v6 = MInst::CvtUint64ToFloatSeq {

3628

        dst_size: v2.clone(),

3629

        src: arg1,

3630

        dst: v3,

3631

        tmp_gpr1: v4,

3632

        tmp_gpr2: v5,

3633

};

3634

    let v7 = C::emit(ctx, &v6);

3635

    let v8 = C::writable_xmm_to_xmm(ctx, v3);

3636

    // Rule at src/isa/x64/inst.isle line 2099.

3637

    return v8;

3638

3639

3640

// Generated as internal constructor for term cvt_float_to_uint_seq.

3641

pub fn constructor_cvt_float_to_uint_seq<C: Context>(

3642

    ctx: &mut C,

3643

    arg0: Type,

3644

    arg1: Value,

3645

    arg2: bool,

3646

) -> Gpr {

3647

    let v4 = &C::raw_operand_size_of_type(ctx, arg0);

3648

    let v2 = C::value_type(ctx, arg1);

3649

    let v5 = &C::raw_operand_size_of_type(ctx, v2);

3650

    let v6 = C::temp_writable_gpr(ctx);

3651

    let v7 = C::temp_writable_xmm(ctx);

3652

    let v8 = C::temp_writable_xmm(ctx);

3653

    let v9 = C::temp_writable_gpr(ctx);

3654

    let v10 = constructor_put_in_xmm(ctx, arg1);

3655

    let v11 = MInst::CvtFloatToUintSeq {

3656

        dst_size: v4.clone(),

3657

        src_size: v5.clone(),

3658

        is_saturating: arg2,

3659

        src: v10,

3660

        dst: v6,

3661

        tmp_gpr: v9,

3662

        tmp_xmm: v7,

3663

        tmp_xmm2: v8,

3664

};

3665

    let v12 = C::emit(ctx, &v11);

3666

    let v13 = C::writable_gpr_to_gpr(ctx, v6);

3667

    // Rule at src/isa/x64/inst.isle line 2108.

3668

    return v13;

3669

3670

3671

// Generated as internal constructor for term cvt_float_to_sint_seq.

3672

pub fn constructor_cvt_float_to_sint_seq<C: Context>(

3673

    ctx: &mut C,

3674

    arg0: Type,

3675

    arg1: Value,

3676

    arg2: bool,

3677

) -> Gpr {

3678

    let v4 = &C::raw_operand_size_of_type(ctx, arg0);

3679

    let v2 = C::value_type(ctx, arg1);

3680

    let v5 = &C::raw_operand_size_of_type(ctx, v2);

3681

    let v6 = C::temp_writable_gpr(ctx);

3682

    let v7 = C::temp_writable_xmm(ctx);

3683

    let v8 = C::temp_writable_gpr(ctx);

3684

    let v9 = constructor_put_in_xmm(ctx, arg1);

3685

    let v10 = MInst::CvtFloatToSintSeq {

3686

        dst_size: v4.clone(),

3687

        src_size: v5.clone(),

3688

        is_saturating: arg2,

3689

        src: v9,

3690

        dst: v6,

3691

        tmp_gpr: v8,

3692

        tmp_xmm: v7,

3693

};

3694

    let v11 = C::emit(ctx, &v10);

3695

    let v12 = C::writable_gpr_to_gpr(ctx, v6);

3696

    // Rule at src/isa/x64/inst.isle line 2120.

3697

    return v12;

3698

3699

3700

// Generated as internal constructor for term mov_from_preg.

3701

pub fn constructor_mov_from_preg<C: Context>(ctx: &mut C, arg0: PReg) -> Reg {

3702

    let v1 = C::temp_writable_gpr(ctx);

3703

    let v2 = MInst::MovFromPReg { src: arg0, dst: v1 };

3704

    let v3 = C::emit(ctx, &v2);

3705

    let v4 = constructor_writable_gpr_to_r_reg(ctx, v1);

3706

    // Rule at src/isa/x64/inst.isle line 2132.

3707

    return v4;

3708

3709

3710

// Generated as internal constructor for term extend_to_gpr.

3711

pub fn constructor_extend_to_gpr<C: Context>(

3712

    ctx: &mut C,

3713

    arg0: Value,

3714

    arg1: Type,

3715

    arg2: &ExtendKind,

3716

) -> Gpr {

3717

    let v1 = C::value_type(ctx, arg0);

3718

    if v1 == arg1 {

3719

        let v4 = constructor_put_in_gpr(ctx, arg0);

3720

        // Rule at src/isa/x64/inst.isle line 2156.

3721

        return v4;

3722

3723

    if v1 == I32 {

3724

        if arg1 == I64 {

3725

            if let &ExtendKind::Zero = arg2 {

3726

                let v5 = constructor_value32_zeros_upper32(ctx, arg0);

3727

                if v5 == true {

3728

                    let v4 = constructor_put_in_gpr(ctx, arg0);

3729

                    // Rule at src/isa/x64/inst.isle line 2164.

3730

                    return v4;

3731

3732

3733

3734

3735

    let v7 = &C::operand_size_of_type_32_64(ctx, arg1);

3736

    let v8 = constructor_operand_size_bits(ctx, v7);

3737

    let v6 = C::ty_bits_u16(ctx, v1);

3738

    let v9 = &C::ext_mode(ctx, v6, v8);

3739

    let v10 = &constructor_put_in_gpr_mem(ctx, arg0);

3740

    let v11 = constructor_extend(ctx, arg2, arg1, v9, v10);

3741

    // Rule at src/isa/x64/inst.isle line 2168.

3742

    return v11;

3743

3744

3745

// Generated as internal constructor for term extend.

3746

pub fn constructor_extend<C: Context>(

3747

    ctx: &mut C,

3748

    arg0: &ExtendKind,

3749

    arg1: Type,

3750

    arg2: &ExtMode,

3751

    arg3: &GprMem,

3752

) -> Gpr {

3753

    match arg0 {

3754

        &ExtendKind::Sign => {

3755

            let v5 = constructor_x64_movsx(ctx, arg2, arg3);

3756

            // Rule at src/isa/x64/inst.isle line 2188.

3757

            return v5;

3758

3759

        &ExtendKind::Zero => {

3760

            let v4 = constructor_x64_movzx(ctx, arg2, arg3);

3761

            // Rule at src/isa/x64/inst.isle line 2184.

3762

            return v4;

3763

3764

        _ => {}

3765

3766

    unreachable!(

3767

        "no rule matched for term {} at {}; should it be partial?",

3768

        "extend", "src/isa/x64/inst.isle line 2181"

3769

3770

3771

3772

// Generated as internal constructor for term value32_zeros_upper32.

3773

pub fn constructor_value32_zeros_upper32<C: Context>(ctx: &mut C, arg0: Value) -> bool {

3774

    let v1 = C::def_inst(ctx, arg0);

3775

    if let Some(v2) = v1 {

3776

        let v3 = &C::inst_data(ctx, v2);

3777

        match v3 {

3778

            &InstructionData::Binary {

3779

                opcode: ref v4,

3780

                args: ref v5,

3781

            } => {

3782

                match v4 {

3783

                    &Opcode::Iadd => {

3784

                        // Rule at src/isa/x64/inst.isle line 2195.

3785

                        return true;

3786

3787

                    &Opcode::Isub => {

3788

                        // Rule at src/isa/x64/inst.isle line 2196.

3789

                        return true;

3790

3791

                    &Opcode::Imul => {

3792

                        // Rule at src/isa/x64/inst.isle line 2197.

3793

                        return true;

3794

3795

                    &Opcode::Band => {

3796

                        // Rule at src/isa/x64/inst.isle line 2198.

3797

                        return true;

3798

3799

                    &Opcode::Bor => {

3800

                        // Rule at src/isa/x64/inst.isle line 2199.

3801

                        return true;

3802

3803

                    &Opcode::Bxor => {

3804

                        // Rule at src/isa/x64/inst.isle line 2200.

3805

                        return true;

3806

3807

                    &Opcode::Ishl => {

3808

                        // Rule at src/isa/x64/inst.isle line 2201.

3809

                        return true;

3810

3811

                    &Opcode::Ushr => {

3812

                        // Rule at src/isa/x64/inst.isle line 2202.

3813

                        return true;

3814

3815

                    _ => {}

3816

3817

3818

            &InstructionData::Load {

3819

                opcode: ref v10,

3820

                arg: v11,

3821

                flags: v12,

3822

                offset: v13,

3823

            } => {

3824

                if let &Opcode::Uload32 = v10 {

3825

                    // Rule at src/isa/x64/inst.isle line 2203.

3826

                    return true;

3827

3828

3829

            _ => {}

3830

3831

3832

    // Rule at src/isa/x64/inst.isle line 2204.

3833

    return false;

3834

3835

3836

// Generated as internal constructor for term vec_int_type.

3837

pub fn constructor_vec_int_type<C: Context>(ctx: &mut C, arg0: Type) -> Type {

3838

    let v1 = C::multi_lane(ctx, arg0);

3839

    if let Some(v2) = v1 {

3840

        match v2.0 {

3841

            0x8 => {

3842

                if v2.1 == 0x10 {

3843

                    // Rule at src/isa/x64/inst.isle line 2210.

3844

                    return I8X16;

3845

3846

3847

            0x10 => {

3848

                if v2.1 == 0x8 {

3849

                    // Rule at src/isa/x64/inst.isle line 2211.

3850

                    return I16X8;

3851

3852

3853

            0x20 => {

3854

                if v2.1 == 0x4 {

3855

                    // Rule at src/isa/x64/inst.isle line 2212.

3856

                    return I32X4;

3857

3858

3859

            0x40 => {

3860

                if v2.1 == 0x2 {

3861

                    // Rule at src/isa/x64/inst.isle line 2213.

3862

                    return I64X2;

3863

3864

3865

            _ => {}

3866

3867

3868

    unreachable!(

3869

        "no rule matched for term {} at {}; should it be partial?",

3870

        "vec_int_type", "src/isa/x64/inst.isle line 2209"

3871

3872

3873

3874

// Generated as internal constructor for term x64_xor_vector.

3875

pub fn constructor_x64_xor_vector<C: Context>(

3876

    ctx: &mut C,

3877

    arg0: Type,

3878

    arg1: Xmm,

3879

    arg2: &XmmMem,

3880

) -> Xmm {

3881

    match arg0 {

3882

        F32 => {

3883

            let v3 = constructor_x64_xorps(ctx, arg1, arg2);

3884

            // Rule at src/isa/x64/inst.isle line 2217.

3885

            return v3;

3886

3887

        F64 => {

3888

            let v4 = constructor_x64_xorpd(ctx, arg1, arg2);

3889

            // Rule at src/isa/x64/inst.isle line 2218.

3890

            return v4;

3891

3892

        F32X4 => {

3893

            let v3 = constructor_x64_xorps(ctx, arg1, arg2);

3894

            // Rule at src/isa/x64/inst.isle line 2219.

3895

            return v3;

3896

3897

        F64X2 => {

3898

            let v4 = constructor_x64_xorpd(ctx, arg1, arg2);

3899

            // Rule at src/isa/x64/inst.isle line 2220.

3900

            return v4;

3901

3902

        _ => {}

3903

3904

    let v5 = C::multi_lane(ctx, arg0);

3905

    if let Some(v6) = v5 {

3906

        let v9 = constructor_x64_pxor(ctx, arg1, arg2);

3907

        // Rule at src/isa/x64/inst.isle line 2221.

3908

        return v9;

3909

3910

    unreachable!(

3911

        "no rule matched for term {} at {}; should it be partial?",

3912

        "x64_xor_vector", "src/isa/x64/inst.isle line 2216"

3913

3914

3915

3916

// Generated as internal constructor for term vector_all_ones.

3917

pub fn constructor_vector_all_ones<C: Context>(ctx: &mut C) -> Xmm {

3918

    let v0 = constructor_xmm_uninit_value(ctx);

3919

    let v1 = &C::xmm_to_xmm_mem(ctx, v0);

3920

    let v2 = constructor_x64_pcmpeqd(ctx, v0, v1);

3921

    // Rule at src/isa/x64/inst.isle line 2233.

3922

    return v2;

3923

3924

3925

// Generated as internal constructor for term mov_rmi_to_xmm.

3926

pub fn constructor_mov_rmi_to_xmm<C: Context>(ctx: &mut C, arg0: &RegMemImm) -> XmmMemImm {

3927

    match arg0 {

3928

        &RegMemImm::Reg { reg: v4 } => {

3929

            let v5 = &C::reg_to_gpr_mem(ctx, v4);

3930

            let v6 = constructor_x64_movd_to_xmm(ctx, v5);

3931

            let v7 = &C::xmm_to_xmm_mem_imm(ctx, v6);

3932

            // Rule at src/isa/x64/inst.isle line 2241.

3933

            return v7.clone();

3934

3935

        &RegMemImm::Mem { addr: ref v1 } => {

3936

            let v2 = &C::xmm_mem_imm_new(ctx, arg0);

3937

            // Rule at src/isa/x64/inst.isle line 2239.

3938

            return v2.clone();

3939

3940

        &RegMemImm::Imm { simm32: v3 } => {

3941

            let v2 = &C::xmm_mem_imm_new(ctx, arg0);

3942

            // Rule at src/isa/x64/inst.isle line 2240.

3943

            return v2.clone();

3944

3945

        _ => {}

3946

3947

    unreachable!(

3948

        "no rule matched for term {} at {}; should it be partial?",

3949

        "mov_rmi_to_xmm", "src/isa/x64/inst.isle line 2238"

3950

3951

3952

3953

// Generated as internal constructor for term x64_load.

3954

pub fn constructor_x64_load<C: Context>(

3955

    ctx: &mut C,

3956

    arg0: Type,

3957

    arg1: &SyntheticAmode,

3958

    arg2: &ExtKind,

3959

) -> Reg {

3960

    match arg0 {

3961

        I64 => {

3962

            let v11 = constructor_mov64_mr(ctx, arg1);

3963

            // Rule at src/isa/x64/inst.isle line 2260.

3964

            return v11;

3965

3966

        F32 => {

3967

            let v12 = constructor_x64_movss_load(ctx, arg1);

3968

            let v13 = C::xmm_to_reg(ctx, v12);

3969

            // Rule at src/isa/x64/inst.isle line 2263.

3970

            return v13;

3971

3972

        F64 => {

3973

            let v14 = constructor_x64_movsd_load(ctx, arg1);

3974

            let v15 = C::xmm_to_reg(ctx, v14);

3975

            // Rule at src/isa/x64/inst.isle line 2266.

3976

            return v15;

3977

3978

        F32X4 => {

3979

            let v16 = constructor_x64_movups_load(ctx, arg1);

3980

            let v17 = C::xmm_to_reg(ctx, v16);

3981

            // Rule at src/isa/x64/inst.isle line 2269.

3982

            return v17;

3983

3984

        F64X2 => {

3985

            let v18 = constructor_x64_movupd_load(ctx, arg1);

3986

            let v19 = C::xmm_to_reg(ctx, v18);

3987

            // Rule at src/isa/x64/inst.isle line 2272.

3988

            return v19;

3989

3990

        _ => {}

3991

3992

    let v1 = C::fits_in_32(ctx, arg0);

3993

    if let Some(v2) = v1 {

3994

        if let &ExtKind::SignExtend = arg2 {

3995

            let v5 = C::ty_bytes(ctx, v2);

3996

            let v7 = &C::ext_mode(ctx, v5, 0x8);

3997

            let v8 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg1);

3998

            let v9 = constructor_x64_movsx(ctx, v7, v8);

3999

            let v10 = C::gpr_to_reg(ctx, v9);

4000

            // Rule at src/isa/x64/inst.isle line 2256.

4001

            return v10;

4002

4003

4004

    let v20 = C::multi_lane(ctx, arg0);

4005

    if let Some(v21) = v20 {

4006

        let v24 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg1);

4007

        let v25 = constructor_x64_movdqu_load(ctx, v24);

4008

        let v26 = C::xmm_to_reg(ctx, v25);

4009

        // Rule at src/isa/x64/inst.isle line 2275.

4010

        return v26;

4011

4012

    unreachable!(

4013

        "no rule matched for term {} at {}; should it be partial?",

4014

        "x64_load", "src/isa/x64/inst.isle line 2254"

4015

4016

4017

4018

// Generated as internal constructor for term x64_mov.

4019

pub fn constructor_x64_mov<C: Context>(ctx: &mut C, arg0: &Amode) -> Reg {

4020

    let v1 = &C::amode_to_synthetic_amode(ctx, arg0);

4021

    let v2 = constructor_mov64_mr(ctx, v1);

4022

    // Rule at src/isa/x64/inst.isle line 2279.

4023

    return v2;

4024

4025

4026

// Generated as internal constructor for term x64_movzx.

4027

pub fn constructor_x64_movzx<C: Context>(ctx: &mut C, arg0: &ExtMode, arg1: &GprMem) -> Gpr {

4028

    let v2 = C::temp_writable_gpr(ctx);

4029

    let v3 = MInst::MovzxRmR {

4030

        ext_mode: arg0.clone(),

4031

        src: arg1.clone(),

4032

        dst: v2,

4033

};

4034

    let v4 = C::emit(ctx, &v3);

4035

    let v5 = C::writable_gpr_to_gpr(ctx, v2);

4036

    // Rule at src/isa/x64/inst.isle line 2283.

4037

    return v5;

4038

4039

4040

// Generated as internal constructor for term x64_movsx.

4041

pub fn constructor_x64_movsx<C: Context>(ctx: &mut C, arg0: &ExtMode, arg1: &GprMem) -> Gpr {

4042

    let v2 = C::temp_writable_gpr(ctx);

4043

    let v3 = MInst::MovsxRmR {

4044

        ext_mode: arg0.clone(),

4045

        src: arg1.clone(),

4046

        dst: v2,

4047

};

4048

    let v4 = C::emit(ctx, &v3);

4049

    let v5 = C::writable_gpr_to_gpr(ctx, v2);

4050

    // Rule at src/isa/x64/inst.isle line 2289.

4051

    return v5;

4052

4053

4054

// Generated as internal constructor for term x64_movss_load.

4055

pub fn constructor_x64_movss_load<C: Context>(ctx: &mut C, arg0: &SyntheticAmode) -> Xmm {

4056

    let v4 = C::use_avx(ctx);

4057

    if v4 == true {

4058

        let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);

4059

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vmovss, v2);

4060

        // Rule at src/isa/x64/inst.isle line 2297.

4061

        return v6;

4062

4063

    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);

4064

    let v3 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Movss, v2);

4065

    // Rule at src/isa/x64/inst.isle line 2295.

4066

    return v3;

4067

4068

4069

// Generated as internal constructor for term x64_movss_store.

4070

pub fn constructor_x64_movss_store<C: Context>(

4071

    ctx: &mut C,

4072

    arg0: &SyntheticAmode,

4073

    arg1: Xmm,

4074

) -> SideEffectNoResult {

4075

    let v4 = C::use_avx(ctx);

4076

    if v4 == true {

4077

        let v6 = &constructor_xmm_movrm_vex(ctx, &AvxOpcode::Vmovss, arg0, arg1);

4078

        // Rule at src/isa/x64/inst.isle line 2304.

4079

        return v6.clone();

4080

4081

    let v3 = &constructor_xmm_movrm(ctx, &SseOpcode::Movss, arg0, arg1);

4082

    // Rule at src/isa/x64/inst.isle line 2302.

4083

    return v3.clone();

4084

4085

4086

// Generated as internal constructor for term x64_movsd_load.

4087

pub fn constructor_x64_movsd_load<C: Context>(ctx: &mut C, arg0: &SyntheticAmode) -> Xmm {

4088

    let v4 = C::use_avx(ctx);

4089

    if v4 == true {

4090

        let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);

4091

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vmovsd, v2);

4092

        // Rule at src/isa/x64/inst.isle line 2311.

4093

        return v6;

4094

4095

    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);

4096

    let v3 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Movsd, v2);

4097

    // Rule at src/isa/x64/inst.isle line 2309.

4098

    return v3;

4099

4100

4101

// Generated as internal constructor for term x64_movsd_store.

4102

pub fn constructor_x64_movsd_store<C: Context>(

4103

    ctx: &mut C,

4104

    arg0: &SyntheticAmode,

4105

    arg1: Xmm,

4106

) -> SideEffectNoResult {

4107

    let v4 = C::use_avx(ctx);

4108

    if v4 == true {

4109

        let v6 = &constructor_xmm_movrm_vex(ctx, &AvxOpcode::Vmovsd, arg0, arg1);

4110

        // Rule at src/isa/x64/inst.isle line 2318.

4111

        return v6.clone();

4112

4113

    let v3 = &constructor_xmm_movrm(ctx, &SseOpcode::Movsd, arg0, arg1);

4114

    // Rule at src/isa/x64/inst.isle line 2316.

4115

    return v3.clone();

4116

4117

4118

// Generated as internal constructor for term x64_movups_load.

4119

pub fn constructor_x64_movups_load<C: Context>(ctx: &mut C, arg0: &SyntheticAmode) -> Xmm {

4120

    let v4 = C::use_avx(ctx);

4121

    if v4 == true {

4122

        let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);

4123

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vmovups, v2);

4124

        // Rule at src/isa/x64/inst.isle line 2325.

4125

        return v6;

4126

4127

    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);

4128

    let v3 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Movups, v2);

4129

    // Rule at src/isa/x64/inst.isle line 2323.

4130

    return v3;

4131

4132

4133

// Generated as internal constructor for term x64_movups_store.

4134

pub fn constructor_x64_movups_store<C: Context>(

4135

    ctx: &mut C,

4136

    arg0: &SyntheticAmode,

4137

    arg1: Xmm,

4138

) -> SideEffectNoResult {

4139

    let v4 = C::use_avx(ctx);

4140

    if v4 == true {

4141

        let v6 = &constructor_xmm_movrm_vex(ctx, &AvxOpcode::Vmovups, arg0, arg1);

4142

        // Rule at src/isa/x64/inst.isle line 2332.

4143

        return v6.clone();

4144

4145

    let v3 = &constructor_xmm_movrm(ctx, &SseOpcode::Movups, arg0, arg1);

4146

    // Rule at src/isa/x64/inst.isle line 2330.

4147

    return v3.clone();

4148

4149

4150

// Generated as internal constructor for term x64_movupd_load.

4151

pub fn constructor_x64_movupd_load<C: Context>(ctx: &mut C, arg0: &SyntheticAmode) -> Xmm {

4152

    let v4 = C::use_avx(ctx);

4153

    if v4 == true {

4154

        let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);

4155

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vmovupd, v2);

4156

        // Rule at src/isa/x64/inst.isle line 2339.

4157

        return v6;

4158

4159

    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);

4160

    let v3 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Movupd, v2);

4161

    // Rule at src/isa/x64/inst.isle line 2337.

4162

    return v3;

4163

4164

4165

// Generated as internal constructor for term x64_movupd_store.

4166

pub fn constructor_x64_movupd_store<C: Context>(

4167

    ctx: &mut C,

4168

    arg0: &SyntheticAmode,

4169

    arg1: Xmm,

4170

) -> SideEffectNoResult {

4171

    let v4 = C::use_avx(ctx);

4172

    if v4 == true {

4173

        let v6 = &constructor_xmm_movrm_vex(ctx, &AvxOpcode::Vmovupd, arg0, arg1);

4174

        // Rule at src/isa/x64/inst.isle line 2346.

4175

        return v6.clone();

4176

4177

    let v3 = &constructor_xmm_movrm(ctx, &SseOpcode::Movupd, arg0, arg1);

4178

    // Rule at src/isa/x64/inst.isle line 2344.

4179

    return v3.clone();

4180

4181

4182

// Generated as internal constructor for term x64_movd_to_gpr.

4183

pub fn constructor_x64_movd_to_gpr<C: Context>(ctx: &mut C, arg0: Xmm) -> Gpr {

4184

    let v4 = C::use_avx(ctx);

4185

    if v4 == true {

4186

        let v6 = constructor_xmm_to_gpr_vex(ctx, &AvxOpcode::Vmovd, arg0, &OperandSize::Size32);

4187

        // Rule at src/isa/x64/inst.isle line 2354.

4188

        return v6;

4189

4190

    let v3 = constructor_xmm_to_gpr(ctx, &SseOpcode::Movd, arg0, &OperandSize::Size32);

4191

    // Rule at src/isa/x64/inst.isle line 2352.

4192

    return v3;

4193

4194

4195

// Generated as internal constructor for term x64_movd_to_xmm.

4196

pub fn constructor_x64_movd_to_xmm<C: Context>(ctx: &mut C, arg0: &GprMem) -> Xmm {

4197

    let v4 = C::use_avx(ctx);

4198

    if v4 == true {

4199

        let v6 = constructor_gpr_to_xmm_vex(ctx, &AvxOpcode::Vmovd, arg0, &OperandSize::Size32);

4200

        // Rule at src/isa/x64/inst.isle line 2362.

4201

        return v6;

4202

4203

    let v3 = constructor_gpr_to_xmm(ctx, &SseOpcode::Movd, arg0, &OperandSize::Size32);

4204

    // Rule at src/isa/x64/inst.isle line 2360.

4205

    return v3;

4206

4207

4208

// Generated as internal constructor for term x64_movq_to_xmm.

4209

pub fn constructor_x64_movq_to_xmm<C: Context>(ctx: &mut C, arg0: &GprMem) -> Xmm {

4210

    let v4 = C::use_avx(ctx);

4211

    if v4 == true {

4212

        let v6 = constructor_gpr_to_xmm_vex(ctx, &AvxOpcode::Vmovq, arg0, &OperandSize::Size64);

4213

        // Rule at src/isa/x64/inst.isle line 2370.

4214

        return v6;

4215

4216

    let v3 = constructor_gpr_to_xmm(ctx, &SseOpcode::Movq, arg0, &OperandSize::Size64);

4217

    // Rule at src/isa/x64/inst.isle line 2368.

4218

    return v3;

4219

4220

4221

// Generated as internal constructor for term x64_movq_to_gpr.

4222

pub fn constructor_x64_movq_to_gpr<C: Context>(ctx: &mut C, arg0: Xmm) -> Gpr {

4223

    let v4 = C::use_avx(ctx);

4224

    if v4 == true {

4225

        let v6 = constructor_xmm_to_gpr_vex(ctx, &AvxOpcode::Vmovq, arg0, &OperandSize::Size64);

4226

        // Rule at src/isa/x64/inst.isle line 2378.

4227

        return v6;

4228

4229

    let v3 = constructor_xmm_to_gpr(ctx, &SseOpcode::Movq, arg0, &OperandSize::Size64);

4230

    // Rule at src/isa/x64/inst.isle line 2376.

4231

    return v3;

4232

4233

4234

// Generated as internal constructor for term x64_movdqu_load.

4235

pub fn constructor_x64_movdqu_load<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

4236

    let v3 = C::use_avx(ctx);

4237

    if v3 == true {

4238

        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vmovdqu, arg0);

4239

        // Rule at src/isa/x64/inst.isle line 2385.

4240

        return v5;

4241

4242

    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Movdqu, arg0);

4243

    // Rule at src/isa/x64/inst.isle line 2383.

4244

    return v2;

4245

4246

4247

// Generated as internal constructor for term x64_movdqu_store.

4248

pub fn constructor_x64_movdqu_store<C: Context>(

4249

    ctx: &mut C,

4250

    arg0: &SyntheticAmode,

4251

    arg1: Xmm,

4252

) -> SideEffectNoResult {

4253

    let v4 = C::use_avx(ctx);

4254

    if v4 == true {

4255

        let v6 = &constructor_xmm_movrm_vex(ctx, &AvxOpcode::Vmovdqu, arg0, arg1);

4256

        // Rule at src/isa/x64/inst.isle line 2392.

4257

        return v6.clone();

4258

4259

    let v3 = &constructor_xmm_movrm(ctx, &SseOpcode::Movdqu, arg0, arg1);

4260

    // Rule at src/isa/x64/inst.isle line 2390.

4261

    return v3.clone();

4262

4263

4264

// Generated as internal constructor for term x64_pmovsxbw.

4265

pub fn constructor_x64_pmovsxbw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

4266

    let v3 = C::use_avx(ctx);

4267

    if v3 == true {

4268

        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpmovsxbw, arg0);

4269

        // Rule at src/isa/x64/inst.isle line 2399.

4270

        return v5;

4271

4272

    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Pmovsxbw, arg0);

4273

    // Rule at src/isa/x64/inst.isle line 2397.

4274

    return v2;

4275

4276

4277

// Generated as internal constructor for term x64_pmovzxbw.

4278

pub fn constructor_x64_pmovzxbw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

4279

    let v3 = C::use_avx(ctx);

4280

    if v3 == true {

4281

        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpmovzxbw, arg0);

4282

        // Rule at src/isa/x64/inst.isle line 2406.

4283

        return v5;

4284

4285

    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Pmovzxbw, arg0);

4286

    // Rule at src/isa/x64/inst.isle line 2404.

4287

    return v2;

4288

4289

4290

// Generated as internal constructor for term x64_pmovsxwd.

4291

pub fn constructor_x64_pmovsxwd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

4292

    let v3 = C::use_avx(ctx);

4293

    if v3 == true {

4294

        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpmovsxwd, arg0);

4295

        // Rule at src/isa/x64/inst.isle line 2413.

4296

        return v5;

4297

4298

    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Pmovsxwd, arg0);

4299

    // Rule at src/isa/x64/inst.isle line 2411.

4300

    return v2;

4301

4302

4303

// Generated as internal constructor for term x64_pmovzxwd.

4304

pub fn constructor_x64_pmovzxwd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

4305

    let v3 = C::use_avx(ctx);

4306

    if v3 == true {

4307

        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpmovzxwd, arg0);

4308

        // Rule at src/isa/x64/inst.isle line 2420.

4309

        return v5;

4310

4311

    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Pmovzxwd, arg0);

4312

    // Rule at src/isa/x64/inst.isle line 2418.

4313

    return v2;

4314

4315

4316

// Generated as internal constructor for term x64_pmovsxdq.

4317

pub fn constructor_x64_pmovsxdq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

4318

    let v3 = C::use_avx(ctx);

4319

    if v3 == true {

4320

        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpmovsxdq, arg0);

4321

        // Rule at src/isa/x64/inst.isle line 2427.

4322

        return v5;

4323

4324

    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Pmovsxdq, arg0);

4325

    // Rule at src/isa/x64/inst.isle line 2425.

4326

    return v2;

4327

4328

4329

// Generated as internal constructor for term x64_pmovzxdq.

4330

pub fn constructor_x64_pmovzxdq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

4331

    let v3 = C::use_avx(ctx);

4332

    if v3 == true {

4333

        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpmovzxdq, arg0);

4334

        // Rule at src/isa/x64/inst.isle line 2434.

4335

        return v5;

4336

4337

    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Pmovzxdq, arg0);

4338

    // Rule at src/isa/x64/inst.isle line 2432.

4339

    return v2;

4340

4341

4342

// Generated as internal constructor for term x64_movrm.

4343

pub fn constructor_x64_movrm<C: Context>(

4344

    ctx: &mut C,

4345

    arg0: Type,

4346

    arg1: &SyntheticAmode,

4347

    arg2: Gpr,

4348

) -> SideEffectNoResult {

4349

    let v3 = &C::raw_operand_size_of_type(ctx, arg0);

4350

    let v4 = MInst::MovRM {

4351

        size: v3.clone(),

4352

        src: arg2,

4353

        dst: arg1.clone(),

4354

};

4355

    let v5 = SideEffectNoResult::Inst { inst: v4 };

4356

    // Rule at src/isa/x64/inst.isle line 2439.

4357

    return v5;

4358

4359

4360

// Generated as internal constructor for term x64_movimm_m.

4361

pub fn constructor_x64_movimm_m<C: Context>(

4362

    ctx: &mut C,

4363

    arg0: Type,

4364

    arg1: &SyntheticAmode,

4365

    arg2: i32,

4366

) -> SideEffectNoResult {

4367

    let v3 = &C::raw_operand_size_of_type(ctx, arg0);

4368

    let v4 = MInst::MovImmM {

4369

        size: v3.clone(),

4370

        simm32: arg2,

4371

        dst: arg1.clone(),

4372

};

4373

    let v5 = SideEffectNoResult::Inst { inst: v4 };

4374

    // Rule at src/isa/x64/inst.isle line 2444.

4375

    return v5;

4376

4377

4378

// Generated as internal constructor for term xmm_movrm.

4379

pub fn constructor_xmm_movrm<C: Context>(

4380

    ctx: &mut C,

4381

    arg0: &SseOpcode,

4382

    arg1: &SyntheticAmode,

4383

    arg2: Xmm,

4384

) -> SideEffectNoResult {

4385

    let v3 = MInst::XmmMovRM {

4386

        op: arg0.clone(),

4387

        src: arg2,

4388

        dst: arg1.clone(),

4389

};

4390

    let v4 = SideEffectNoResult::Inst { inst: v3 };

4391

    // Rule at src/isa/x64/inst.isle line 2449.

4392

    return v4;

4393

4394

4395

// Generated as internal constructor for term xmm_movrm_imm.

4396

pub fn constructor_xmm_movrm_imm<C: Context>(

4397

    ctx: &mut C,

4398

    arg0: &SseOpcode,

4399

    arg1: &SyntheticAmode,

4400

    arg2: Xmm,

4401

    arg3: u8,

4402

) -> SideEffectNoResult {

4403

    let v4 = MInst::XmmMovRMImm {

4404

        op: arg0.clone(),

4405

        src: arg2,

4406

        dst: arg1.clone(),

4407

        imm: arg3,

4408

};

4409

    let v5 = SideEffectNoResult::Inst { inst: v4 };

4410

    // Rule at src/isa/x64/inst.isle line 2453.

4411

    return v5;

4412

4413

4414

// Generated as internal constructor for term xmm_movrm_vex.

4415

pub fn constructor_xmm_movrm_vex<C: Context>(

4416

    ctx: &mut C,

4417

    arg0: &AvxOpcode,

4418

    arg1: &SyntheticAmode,

4419

    arg2: Xmm,

4420

) -> SideEffectNoResult {

4421

    let v3 = MInst::XmmMovRMVex {

4422

        op: arg0.clone(),

4423

        src: arg2,

4424

        dst: arg1.clone(),

4425

};

4426

    let v4 = SideEffectNoResult::Inst { inst: v3 };

4427

    // Rule at src/isa/x64/inst.isle line 2457.

4428

    return v4;

4429

4430

4431

// Generated as internal constructor for term xmm_movrm_imm_vex.

4432

pub fn constructor_xmm_movrm_imm_vex<C: Context>(

4433

    ctx: &mut C,

4434

    arg0: &AvxOpcode,

4435

    arg1: &SyntheticAmode,

4436

    arg2: Xmm,

4437

    arg3: u8,

4438

) -> SideEffectNoResult {

4439

    let v4 = MInst::XmmMovRMImmVex {

4440

        op: arg0.clone(),

4441

        src: arg2,

4442

        dst: arg1.clone(),

4443

        imm: arg3,

4444

};

4445

    let v5 = SideEffectNoResult::Inst { inst: v4 };

4446

    // Rule at src/isa/x64/inst.isle line 2461.

4447

    return v5;

4448

4449

4450

// Generated as internal constructor for term x64_xmm_load_const.

4451

pub fn constructor_x64_xmm_load_const<C: Context>(

4452

    ctx: &mut C,

4453

    arg0: Type,

4454

    arg1: VCodeConstant,

4455

) -> Xmm {

4456

    let v2 = &C::const_to_synthetic_amode(ctx, arg1);

4457

    let v4 = constructor_x64_load(ctx, arg0, v2, &ExtKind::None);

4458

    let v5 = C::xmm_new(ctx, v4);

4459

    // Rule at src/isa/x64/inst.isle line 2466.

4460

    return v5;

4461

4462

4463

// Generated as internal constructor for term x64_add.

4464

pub fn constructor_x64_add<C: Context>(

4465

    ctx: &mut C,

4466

    arg0: Type,

4467

    arg1: Gpr,

4468

    arg2: &GprMemImm,

4469

) -> Gpr {

4470

    let v4 = constructor_alu_rmi_r(ctx, arg0, &AluRmiROpcode::Add, arg1, arg2);

4471

    // Rule at src/isa/x64/inst.isle line 2477.

4472

    return v4;

4473

4474

4475

// Generated as internal constructor for term x64_add_with_flags_paired.

4476

pub fn constructor_x64_add_with_flags_paired<C: Context>(

4477

    ctx: &mut C,

4478

    arg0: Type,

4479

    arg1: Gpr,

4480

    arg2: &GprMemImm,

4481

) -> ProducesFlags {

4482

    let v3 = C::temp_writable_gpr(ctx);

4483

    let v4 = &C::operand_size_of_type_32_64(ctx, arg0);

4484

    let v7 = constructor_writable_gpr_to_r_reg(ctx, v3);

4485

    let v6 = MInst::AluRmiR {

4486

        size: v4.clone(),

4487

        op: AluRmiROpcode::Add,

4488

        src1: arg1,

4489

        src2: arg2.clone(),

4490

        dst: v3,

4491

};

4492

    let v8 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer {

4493

        inst: v6,

4494

        result: v7,

4495

};

4496

    // Rule at src/isa/x64/inst.isle line 2485.

4497

    return v8;

4498

4499

4500

// Generated as internal constructor for term x64_alurmi_with_flags_paired.

4501

pub fn constructor_x64_alurmi_with_flags_paired<C: Context>(

4502

    ctx: &mut C,

4503

    arg0: &AluRmiROpcode,

4504

    arg1: Type,

4505

    arg2: Gpr,

4506

    arg3: &GprMemImm,

4507

) -> ProducesFlags {

4508

    let v2 = C::fits_in_64(ctx, arg1);

4509

    if let Some(v3) = v2 {

4510

        let v6 = C::temp_writable_gpr(ctx);

4511

        let v7 = &C::raw_operand_size_of_type(ctx, v3);

4512

        let v9 = constructor_writable_gpr_to_r_reg(ctx, v6);

4513

        let v8 = MInst::AluRmiR {

4514

            size: v7.clone(),

4515

            op: arg0.clone(),

4516

            src1: arg2,

4517

            src2: arg3.clone(),

4518

            dst: v6,

4519

};

4520

        let v10 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer {

4521

            inst: v8,

4522

            result: v9,

4523

};

4524

        // Rule at src/isa/x64/inst.isle line 2496.

4525

        return v10;

4526

4527

    unreachable!(

4528

        "no rule matched for term {} at {}; should it be partial?",

4529

        "x64_alurmi_with_flags_paired", "src/isa/x64/inst.isle line 2495"

4530

4531

4532

4533

// Generated as internal constructor for term x64_alurmi_with_flags_chained.

4534

pub fn constructor_x64_alurmi_with_flags_chained<C: Context>(

4535

    ctx: &mut C,

4536

    arg0: &AluRmiROpcode,

4537

    arg1: Type,

4538

    arg2: Gpr,

4539

    arg3: &GprMemImm,

4540

) -> ConsumesAndProducesFlags {

4541

    let v2 = C::fits_in_64(ctx, arg1);

4542

    if let Some(v3) = v2 {

4543

        let v6 = C::temp_writable_gpr(ctx);

4544

        let v7 = &C::raw_operand_size_of_type(ctx, v3);

4545

        let v9 = constructor_writable_gpr_to_r_reg(ctx, v6);

4546

        let v8 = MInst::AluRmiR {

4547

            size: v7.clone(),

4548

            op: arg0.clone(),

4549

            src1: arg2,

4550

            src2: arg3.clone(),

4551

            dst: v6,

4552

};

4553

        let v10 = ConsumesAndProducesFlags::ReturnsReg {

4554

            inst: v8,

4555

            result: v9,

4556

};

4557

        // Rule at src/isa/x64/inst.isle line 2508.

4558

        return v10;

4559

4560

    unreachable!(

4561

        "no rule matched for term {} at {}; should it be partial?",

4562

        "x64_alurmi_with_flags_chained", "src/isa/x64/inst.isle line 2507"

4563

4564

4565

4566

// Generated as internal constructor for term x64_adc_paired.

4567

pub fn constructor_x64_adc_paired<C: Context>(

4568

    ctx: &mut C,

4569

    arg0: Type,

4570

    arg1: Gpr,

4571

    arg2: &GprMemImm,

4572

) -> ConsumesFlags {

4573

    let v3 = C::temp_writable_gpr(ctx);

4574

    let v4 = &C::operand_size_of_type_32_64(ctx, arg0);

4575

    let v7 = constructor_writable_gpr_to_r_reg(ctx, v3);

4576

    let v6 = MInst::AluRmiR {

4577

        size: v4.clone(),

4578

        op: AluRmiROpcode::Adc,

4579

        src1: arg1,

4580

        src2: arg2.clone(),

4581

        dst: v3,

4582

};

4583

    let v8 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {

4584

        inst: v6,

4585

        result: v7,

4586

};

4587

    // Rule at src/isa/x64/inst.isle line 2520.

4588

    return v8;

4589

4590

4591

// Generated as internal constructor for term x64_sub.

4592

pub fn constructor_x64_sub<C: Context>(

4593

    ctx: &mut C,

4594

    arg0: Type,

4595

    arg1: Gpr,

4596

    arg2: &GprMemImm,

4597

) -> Gpr {

4598

    let v4 = constructor_alu_rmi_r(ctx, arg0, &AluRmiROpcode::Sub, arg1, arg2);

4599

    // Rule at src/isa/x64/inst.isle line 2532.

4600

    return v4;

4601

4602

4603

// Generated as internal constructor for term x64_sub_with_flags_paired.

4604

pub fn constructor_x64_sub_with_flags_paired<C: Context>(

4605

    ctx: &mut C,

4606

    arg0: Type,

4607

    arg1: Gpr,

4608

    arg2: &GprMemImm,

4609

) -> ProducesFlags {

4610

    let v3 = C::temp_writable_gpr(ctx);

4611

    let v4 = &C::operand_size_of_type_32_64(ctx, arg0);

4612

    let v7 = constructor_writable_gpr_to_r_reg(ctx, v3);

4613

    let v6 = MInst::AluRmiR {

4614

        size: v4.clone(),

4615

        op: AluRmiROpcode::Sub,

4616

        src1: arg1,

4617

        src2: arg2.clone(),

4618

        dst: v3,

4619

};

4620

    let v8 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer {

4621

        inst: v6,

4622

        result: v7,

4623

};

4624

    // Rule at src/isa/x64/inst.isle line 2540.

4625

    return v8;

4626

4627

4628

// Generated as internal constructor for term x64_sbb_paired.

4629

pub fn constructor_x64_sbb_paired<C: Context>(

4630

    ctx: &mut C,

4631

    arg0: Type,

4632

    arg1: Gpr,

4633

    arg2: &GprMemImm,

4634

) -> ConsumesFlags {

4635

    let v3 = C::temp_writable_gpr(ctx);

4636

    let v4 = &C::operand_size_of_type_32_64(ctx, arg0);

4637

    let v7 = constructor_writable_gpr_to_r_reg(ctx, v3);

4638

    let v6 = MInst::AluRmiR {

4639

        size: v4.clone(),

4640

        op: AluRmiROpcode::Sbb,

4641

        src1: arg1,

4642

        src2: arg2.clone(),

4643

        dst: v3,

4644

};

4645

    let v8 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {

4646

        inst: v6,

4647

        result: v7,

4648

};

4649

    // Rule at src/isa/x64/inst.isle line 2552.

4650

    return v8;

4651

4652

4653

// Generated as internal constructor for term x64_mul.

4654

pub fn constructor_x64_mul<C: Context>(

4655

    ctx: &mut C,

4656

    arg0: Type,

4657

    arg1: Gpr,

4658

    arg2: &GprMemImm,

4659

) -> Gpr {

4660

    let v4 = constructor_alu_rmi_r(ctx, arg0, &AluRmiROpcode::Mul, arg1, arg2);

4661

    // Rule at src/isa/x64/inst.isle line 2564.

4662

    return v4;

4663

4664

4665

// Generated as internal constructor for term x64_umullo.

4666

pub fn constructor_x64_umullo<C: Context>(

4667

    ctx: &mut C,

4668

    arg0: Type,

4669

    arg1: Gpr,

4670

    arg2: &GprMem,

4671

) -> Gpr {

4672

    let v3 = C::temp_writable_gpr(ctx);

4673

    let v4 = &C::raw_operand_size_of_type(ctx, arg0);

4674

    let v5 = MInst::UMulLo {

4675

        size: v4.clone(),

4676

        src1: arg1,

4677

        src2: arg2.clone(),

4678

        dst: v3,

4679

};

4680

    let v6 = C::emit(ctx, &v5);

4681

    let v7 = C::writable_gpr_to_gpr(ctx, v3);

4682

    // Rule at src/isa/x64/inst.isle line 2572.

4683

    return v7;

4684

4685

4686

// Generated as internal constructor for term x64_umullo_with_flags_paired.

4687

pub fn constructor_x64_umullo_with_flags_paired<C: Context>(

4688

    ctx: &mut C,

4689

    arg0: Type,

4690

    arg1: Gpr,

4691

    arg2: &GprMem,

4692

) -> ProducesFlags {

4693

    let v3 = C::temp_writable_gpr(ctx);

4694

    let v4 = &C::raw_operand_size_of_type(ctx, arg0);

4695

    let v6 = constructor_writable_gpr_to_r_reg(ctx, v3);

4696

    let v5 = MInst::UMulLo {

4697

        size: v4.clone(),

4698

        src1: arg1,

4699

        src2: arg2.clone(),

4700

        dst: v3,

4701

};

4702

    let v7 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer {

4703

        inst: v5,

4704

        result: v6,

4705

};

4706

    // Rule at src/isa/x64/inst.isle line 2579.

4707

    return v7;

4708

4709

4710

// Generated as internal constructor for term x64_and.

4711

pub fn constructor_x64_and<C: Context>(

4712

    ctx: &mut C,

4713

    arg0: Type,

4714

    arg1: Gpr,

4715

    arg2: &GprMemImm,

4716

) -> Gpr {

4717

    let v4 = constructor_alu_rmi_r(ctx, arg0, &AluRmiROpcode::And, arg1, arg2);

4718

    // Rule at src/isa/x64/inst.isle line 2590.

4719

    return v4;

4720

4721

4722

// Generated as internal constructor for term x64_and_with_flags_paired.

4723

pub fn constructor_x64_and_with_flags_paired<C: Context>(

4724

    ctx: &mut C,

4725

    arg0: Type,

4726

    arg1: Gpr,

4727

    arg2: &GprMemImm,

4728

) -> ProducesFlags {

4729

    let v3 = C::temp_writable_gpr(ctx);

4730

    let v4 = &C::operand_size_of_type_32_64(ctx, arg0);

4731

    let v6 = MInst::AluRmiR {

4732

        size: v4.clone(),

4733

        op: AluRmiROpcode::And,

4734

        src1: arg1,

4735

        src2: arg2.clone(),

4736

        dst: v3,

4737

};

4738

    let v7 = ProducesFlags::ProducesFlagsSideEffect { inst: v6 };

4739

    // Rule at src/isa/x64/inst.isle line 2597.

4740

    return v7;

4741

4742

4743

// Generated as internal constructor for term x64_or.

4744

pub fn constructor_x64_or<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: &GprMemImm) -> Gpr {

4745

    let v4 = constructor_alu_rmi_r(ctx, arg0, &AluRmiROpcode::Or, arg1, arg2);

4746

    // Rule at src/isa/x64/inst.isle line 2608.

4747

    return v4;

4748

4749

4750

// Generated as internal constructor for term x64_xor.

4751

pub fn constructor_x64_xor<C: Context>(

4752

    ctx: &mut C,

4753

    arg0: Type,

4754

    arg1: Gpr,

4755

    arg2: &GprMemImm,

4756

) -> Gpr {

4757

    let v4 = constructor_alu_rmi_r(ctx, arg0, &AluRmiROpcode::Xor, arg1, arg2);

4758

    // Rule at src/isa/x64/inst.isle line 2616.

4759

    return v4;

4760

4761

4762

// Generated as internal constructor for term x64_andn.

4763

pub fn constructor_x64_andn<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: &GprMem) -> Gpr {

4764

    let v4 = constructor_alu_rm_r_vex(ctx, arg0, &AluRmROpcode::Andn, arg1, arg2);

4765

    // Rule at src/isa/x64/inst.isle line 2623.

4766

    return v4;

4767

4768

4769

// Generated as internal constructor for term imm_i64.

4770

pub fn constructor_imm_i64<C: Context>(ctx: &mut C, arg0: Type, arg1: i64) -> Reg {

4771

    let v2 = C::i64_as_u64(ctx, arg1);

4772

    let v3 = constructor_imm(ctx, arg0, v2);

4773

    // Rule at src/isa/x64/inst.isle line 2630.

4774

    return v3;

4775

4776

4777

// Generated as internal constructor for term imm.

4778

pub fn constructor_imm<C: Context>(ctx: &mut C, arg0: Type, arg1: u64) -> Reg {

4779

    match arg0 {

4780

        I64 => {

4781

            let v20 = C::nonzero_u64_fits_in_u32(ctx, arg1);

4782

            if let Some(v21) = v20 {

4783

                let v5 = C::temp_writable_gpr(ctx);

4784

                let v23 = MInst::Imm {

4785

                    dst_size: OperandSize::Size32,

4786

                    simm64: v21,

4787

                    dst: v5,

4788

};

4789

                let v24 = C::emit(ctx, &v23);

4790

                let v25 = constructor_writable_gpr_to_r_reg(ctx, v5);

4791

                // Rule at src/isa/x64/inst.isle line 2661.

4792

                return v25;

4793

4794

4795

        F32 => {

4796

            let v4 = C::u64_is_zero(ctx, arg1);

4797

            match v4 {

4798

                true => {

4799

                    let v35 = constructor_xmm_zero(ctx, arg0);

4800

                    let v36 = C::xmm_to_reg(ctx, v35);

4801

                    // Rule at src/isa/x64/inst.isle line 2679.

4802

                    return v36;

4803

4804

                false => {

4805

                    let v11 = constructor_imm(ctx, I32, arg1);

4806

                    let v12 = &C::reg_to_gpr_mem(ctx, v11);

4807

                    let v13 = constructor_x64_movd_to_xmm(ctx, v12);

4808

                    let v14 = C::xmm_to_reg(ctx, v13);

4809

                    // Rule at src/isa/x64/inst.isle line 2652.

4810

                    return v14;

4811

4812

                _ => {}

4813

4814

4815

        F64 => {

4816

            let v4 = C::u64_is_zero(ctx, arg1);

4817

            match v4 {

4818

                true => {

4819

                    let v35 = constructor_xmm_zero(ctx, arg0);

4820

                    let v36 = C::xmm_to_reg(ctx, v35);

4821

                    // Rule at src/isa/x64/inst.isle line 2684.

4822

                    return v36;

4823

4824

                false => {

4825

                    let v16 = constructor_imm(ctx, I64, arg1);

4826

                    let v17 = &C::reg_to_gpr_mem(ctx, v16);

4827

                    let v18 = constructor_x64_movq_to_xmm(ctx, v17);

4828

                    let v19 = C::xmm_to_reg(ctx, v18);

4829

                    // Rule at src/isa/x64/inst.isle line 2656.

4830

                    return v19;

4831

4832

                _ => {}

4833

4834

4835

        _ => {}

4836

4837

    let v1 = C::fits_in_64(ctx, arg0);

4838

    if let Some(v2) = v1 {

4839

        let v4 = C::u64_is_zero(ctx, arg1);

4840

        match v4 {

4841

            true => {

4842

                let v5 = C::temp_writable_gpr(ctx);

4843

                let v6 = &C::operand_size_of_type_32_64(ctx, v2);

4844

                let v27 = MInst::AluConstOp {

4845

                    op: AluRmiROpcode::Xor,

4846

                    size: v6.clone(),

4847

                    dst: v5,

4848

};

4849

                let v28 = C::emit(ctx, &v27);

4850

                let v29 = C::writable_gpr_to_gpr(ctx, v5);

4851

                let v30 = C::gpr_to_reg(ctx, v29);

4852

                // Rule at src/isa/x64/inst.isle line 2667.

4853

                return v30;

4854

4855

            false => {

4856

                let v5 = C::temp_writable_gpr(ctx);

4857

                let v6 = &C::operand_size_of_type_32_64(ctx, v2);

4858

                let v7 = MInst::Imm {

4859

                    dst_size: v6.clone(),

4860

                    simm64: arg1,

4861

                    dst: v5,

4862

};

4863

                let v8 = C::emit(ctx, &v7);

4864

                let v9 = constructor_writable_gpr_to_r_reg(ctx, v5);

4865

                // Rule at src/isa/x64/inst.isle line 2645.

4866

                return v9;

4867

4868

            _ => {}

4869

4870

4871

    if arg1 == 0x0 {

4872

        let v31 = C::multi_lane(ctx, arg0);

4873

        if let Some(v32) = v31 {

4874

            let v35 = constructor_xmm_zero(ctx, arg0);

4875

            let v36 = C::xmm_to_reg(ctx, v35);

4876

            // Rule at src/isa/x64/inst.isle line 2675.

4877

            return v36;

4878

4879

4880

    unreachable!(

4881

        "no rule matched for term {} at {}; should it be partial?",

4882

        "imm", "src/isa/x64/inst.isle line 2642"

4883

4884

4885

4886

// Generated as internal constructor for term xmm_zero.

4887

pub fn constructor_xmm_zero<C: Context>(ctx: &mut C, arg0: Type) -> Xmm {

4888

    let v1 = constructor_xmm_uninit_value(ctx);

4889

    let v2 = &C::xmm_to_xmm_mem(ctx, v1);

4890

    let v3 = constructor_x64_xor_vector(ctx, arg0, v1, v2);

4891

    // Rule at src/isa/x64/inst.isle line 2689.

4892

    return v3;

4893

4894

4895

// Generated as internal constructor for term shift_r.

4896

pub fn constructor_shift_r<C: Context>(

4897

    ctx: &mut C,

4898

    arg0: Type,

4899

    arg1: &ShiftKind,

4900

    arg2: Gpr,

4901

    arg3: &Imm8Gpr,

4902

) -> Gpr {

4903

    let v4 = C::temp_writable_gpr(ctx);

4904

    let v5 = &C::raw_operand_size_of_type(ctx, arg0);

4905

    let v6 = MInst::ShiftR {

4906

        size: v5.clone(),

4907

        kind: arg1.clone(),

4908

        src: arg2,

4909

        num_bits: arg3.clone(),

4910

        dst: v4,

4911

};

4912

    let v7 = C::emit(ctx, &v6);

4913

    let v8 = C::writable_gpr_to_gpr(ctx, v4);

4914

    // Rule at src/isa/x64/inst.isle line 2695.

4915

    return v8;

4916

4917

4918

// Generated as internal constructor for term x64_rotl.

4919

pub fn constructor_x64_rotl<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: &Imm8Gpr) -> Gpr {

4920

    let v5 = C::ty_32_or_64(ctx, arg0);

4921

    if let Some(v6) = v5 {

4922

        let v7 = C::imm8_from_imm8_gpr(ctx, arg2);

4923

        if let Some(v8) = v7 {

4924

            let v9 = C::use_bmi2(ctx);

4925

            if v9 == true {

4926

                let v10 = &C::gpr_to_gpr_mem(ctx, arg1);

4927

                let v11 = C::ty_bits(ctx, v6);

4928

                let v12 = C::u8_sub(ctx, v11, v8);

4929

                let v13 = constructor_x64_rorx(ctx, v6, v10, v12);

4930

                // Rule at src/isa/x64/inst.isle line 2707.

4931

                return v13;

4932

4933

4934

4935

    let v4 = constructor_shift_r(ctx, arg0, &ShiftKind::RotateLeft, arg1, arg2);

4936

    // Rule at src/isa/x64/inst.isle line 2705.

4937

    return v4;

4938

4939

4940

// Generated as internal constructor for term x64_rotr.

4941

pub fn constructor_x64_rotr<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: &Imm8Gpr) -> Gpr {

4942

    let v5 = C::ty_32_or_64(ctx, arg0);

4943

    if let Some(v6) = v5 {

4944

        let v7 = C::imm8_from_imm8_gpr(ctx, arg2);

4945

        if let Some(v8) = v7 {

4946

            let v9 = C::use_bmi2(ctx);

4947

            if v9 == true {

4948

                let v10 = &C::gpr_to_gpr_mem(ctx, arg1);

4949

                let v11 = constructor_x64_rorx(ctx, v6, v10, v8);

4950

                // Rule at src/isa/x64/inst.isle line 2715.

4951

                return v11;

4952

4953

4954

4955

    let v4 = constructor_shift_r(ctx, arg0, &ShiftKind::RotateRight, arg1, arg2);

4956

    // Rule at src/isa/x64/inst.isle line 2713.

4957

    return v4;

4958

4959

4960

// Generated as internal constructor for term x64_shl.

4961

pub fn constructor_x64_shl<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: &Imm8Gpr) -> Gpr {

4962

    let v5 = C::ty_32_or_64(ctx, arg0);

4963

    if let Some(v6) = v5 {

4964

        let v7 = C::gpr_from_imm8_gpr(ctx, arg2);

4965

        if let Some(v8) = v7 {

4966

            let v9 = C::use_bmi2(ctx);

4967

            if v9 == true {

4968

                let v10 = &C::gpr_to_gpr_mem(ctx, arg1);

4969

                let v11 = constructor_x64_shlx(ctx, v6, v10, v8);

4970

                // Rule at src/isa/x64/inst.isle line 2727.

4971

                return v11;

4972

4973

4974

4975

    let v4 = constructor_shift_r(ctx, arg0, &ShiftKind::ShiftLeft, arg1, arg2);

4976

    // Rule at src/isa/x64/inst.isle line 2721.

4977

    return v4;

4978

4979

4980

// Generated as internal constructor for term x64_shr.

4981

pub fn constructor_x64_shr<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: &Imm8Gpr) -> Gpr {

4982

    let v5 = C::ty_32_or_64(ctx, arg0);

4983

    if let Some(v6) = v5 {

4984

        let v7 = C::gpr_from_imm8_gpr(ctx, arg2);

4985

        if let Some(v8) = v7 {

4986

            let v9 = C::use_bmi2(ctx);

4987

            if v9 == true {

4988

                let v10 = &C::gpr_to_gpr_mem(ctx, arg1);

4989

                let v11 = constructor_x64_shrx(ctx, v6, v10, v8);

4990

                // Rule at src/isa/x64/inst.isle line 2736.

4991

                return v11;

4992

4993

4994

4995

    let v4 = constructor_shift_r(ctx, arg0, &ShiftKind::ShiftRightLogical, arg1, arg2);

4996

    // Rule at src/isa/x64/inst.isle line 2733.

4997

    return v4;

4998

4999

5000

// Generated as internal constructor for term x64_sar.

5001

pub fn constructor_x64_sar<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: &Imm8Gpr) -> Gpr {

5002

    let v5 = C::ty_32_or_64(ctx, arg0);

5003

    if let Some(v6) = v5 {

5004

        let v7 = C::gpr_from_imm8_gpr(ctx, arg2);

5005

        if let Some(v8) = v7 {

5006

            let v9 = C::use_bmi2(ctx);

5007

            if v9 == true {

5008

                let v10 = &C::gpr_to_gpr_mem(ctx, arg1);

5009

                let v11 = constructor_x64_sarx(ctx, v6, v10, v8);

5010

                // Rule at src/isa/x64/inst.isle line 2745.

5011

                return v11;

5012

5013

5014

5015

    let v4 = constructor_shift_r(ctx, arg0, &ShiftKind::ShiftRightArithmetic, arg1, arg2);

5016

    // Rule at src/isa/x64/inst.isle line 2742.

5017

    return v4;

5018

5019

5020

// Generated as internal constructor for term x64_bzhi.

5021

pub fn constructor_x64_bzhi<C: Context>(ctx: &mut C, arg0: Type, arg1: &GprMem, arg2: Gpr) -> Gpr {

5022

    let v4 = constructor_alu_rm_r_vex(ctx, arg0, &AluRmROpcode::Bzhi, arg2, arg1);

5023

    // Rule at src/isa/x64/inst.isle line 2754.

5024

    return v4;

5025

5026

5027

// Generated as internal constructor for term x64_bswap.

5028

pub fn constructor_x64_bswap<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {

5029

    let v2 = C::temp_writable_gpr(ctx);

5030

    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);

5031

    let v4 = MInst::Bswap {

5032

        size: v3.clone(),

5033

        src: arg1,

5034

        dst: v2,

5035

};

5036

    let v5 = C::emit(ctx, &v4);

5037

    let v6 = C::writable_gpr_to_gpr(ctx, v2);

5038

    // Rule at src/isa/x64/inst.isle line 2761.

5039

    return v6;

5040

5041

5042

// Generated as internal constructor for term cmp_rmi_r.

5043

pub fn constructor_cmp_rmi_r<C: Context>(

5044

    ctx: &mut C,

5045

    arg0: &OperandSize,

5046

    arg1: &CmpOpcode,

5047

    arg2: &GprMemImm,

5048

    arg3: Gpr,

5049

) -> ProducesFlags {

5050

    let v4 = MInst::CmpRmiR {

5051

        size: arg0.clone(),

5052

        opcode: arg1.clone(),

5053

        src: arg2.clone(),

5054

        dst: arg3,

5055

};

5056

    let v5 = ProducesFlags::ProducesFlagsSideEffect { inst: v4 };

5057

    // Rule at src/isa/x64/inst.isle line 2769.

5058

    return v5;

5059

5060

5061

// Generated as internal constructor for term x64_cmp.

5062

pub fn constructor_x64_cmp<C: Context>(

5063

    ctx: &mut C,

5064

    arg0: &OperandSize,

5065

    arg1: &GprMemImm,

5066

    arg2: Gpr,

5067

) -> ProducesFlags {

5068

    let v4 = &constructor_cmp_rmi_r(ctx, arg0, &CmpOpcode::Cmp, arg1, arg2);

5069

    // Rule at src/isa/x64/inst.isle line 2778.

5070

    return v4.clone();

5071

5072

5073

// Generated as internal constructor for term x64_cmp_imm.

5074

pub fn constructor_x64_cmp_imm<C: Context>(

5075

    ctx: &mut C,

5076

    arg0: &OperandSize,

5077

    arg1: u32,

5078

    arg2: Gpr,

5079

) -> ProducesFlags {

5080

    let v4 = RegMemImm::Imm { simm32: arg1 };

5081

    let v5 = &C::gpr_mem_imm_new(ctx, &v4);

5082

    let v6 = &constructor_cmp_rmi_r(ctx, arg0, &CmpOpcode::Cmp, v5, arg2);

5083

    // Rule at src/isa/x64/inst.isle line 2783.

5084

    return v6.clone();

5085

5086

5087

// Generated as internal constructor for term xmm_cmp_rm_r.

5088

pub fn constructor_xmm_cmp_rm_r<C: Context>(

5089

    ctx: &mut C,

5090

    arg0: &SseOpcode,

5091

    arg1: &XmmMemAligned,

5092

    arg2: Xmm,

5093

) -> ProducesFlags {

5094

    let v3 = MInst::XmmCmpRmR {

5095

        op: arg0.clone(),

5096

        src: arg1.clone(),

5097

        dst: arg2,

5098

};

5099

    let v4 = ProducesFlags::ProducesFlagsSideEffect { inst: v3 };

5100

    // Rule at src/isa/x64/inst.isle line 2788.

5101

    return v4;

5102

5103

5104

// Generated as internal constructor for term x64_ucomis.

5105

pub fn constructor_x64_ucomis<C: Context>(ctx: &mut C, arg0: Value, arg1: Value) -> ProducesFlags {

5106

    let v1 = C::value_type(ctx, arg0);

5107

    match v1 {

5108

        F32 => {

5109

            let v4 = constructor_put_in_xmm(ctx, arg0);

5110

            let v5 = &constructor_xmm_to_xmm_mem_aligned(ctx, v4);

5111

            let v6 = constructor_put_in_xmm(ctx, arg1);

5112

            let v7 = &constructor_xmm_cmp_rm_r(ctx, &SseOpcode::Ucomiss, v5, v6);

5113

            // Rule at src/isa/x64/inst.isle line 2794.

5114

            return v7.clone();

5115

5116

        F64 => {

5117

            let v4 = constructor_put_in_xmm(ctx, arg0);

5118

            let v5 = &constructor_xmm_to_xmm_mem_aligned(ctx, v4);

5119

            let v6 = constructor_put_in_xmm(ctx, arg1);

5120

            let v9 = &constructor_xmm_cmp_rm_r(ctx, &SseOpcode::Ucomisd, v5, v6);

5121

            // Rule at src/isa/x64/inst.isle line 2798.

5122

            return v9.clone();

5123

5124

        _ => {}

5125

5126

    unreachable!(

5127

        "no rule matched for term {} at {}; should it be partial?",

5128

        "x64_ucomis", "src/isa/x64/inst.isle line 2793"

5129

5130

5131

5132

// Generated as internal constructor for term x64_test.

5133

pub fn constructor_x64_test<C: Context>(

5134

    ctx: &mut C,

5135

    arg0: &OperandSize,

5136

    arg1: &GprMemImm,

5137

    arg2: Gpr,

5138

) -> ProducesFlags {

5139

    let v4 = &constructor_cmp_rmi_r(ctx, arg0, &CmpOpcode::Test, arg1, arg2);

5140

    // Rule at src/isa/x64/inst.isle line 2803.

5141

    return v4.clone();

5142

5143

5144

// Generated as internal constructor for term x64_ptest.

5145

pub fn constructor_x64_ptest<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: Xmm) -> ProducesFlags {

5146

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

5147

    let v4 = &constructor_xmm_cmp_rm_r(ctx, &SseOpcode::Ptest, v3, arg1);

5148

    // Rule at src/isa/x64/inst.isle line 2808.

5149

    return v4.clone();

5150

5151

5152

// Generated as internal constructor for term cmove.

5153

pub fn constructor_cmove<C: Context>(

5154

    ctx: &mut C,

5155

    arg0: Type,

5156

    arg1: &CC,

5157

    arg2: &GprMem,

5158

    arg3: Gpr,

5159

) -> ConsumesFlags {

5160

    let v4 = C::temp_writable_gpr(ctx);

5161

    let v5 = &C::operand_size_of_type_32_64(ctx, arg0);

5162

    let v7 = constructor_writable_gpr_to_r_reg(ctx, v4);

5163

    let v6 = MInst::Cmove {

5164

        size: v5.clone(),

5165

        cc: arg1.clone(),

5166

        consequent: arg2.clone(),

5167

        alternative: arg3,

5168

        dst: v4,

5169

};

5170

    let v8 = ConsumesFlags::ConsumesFlagsReturnsReg {

5171

        inst: v6,

5172

        result: v7,

5173

};

5174

    // Rule at src/isa/x64/inst.isle line 2815.

5175

    return v8;

5176

5177

5178

// Generated as internal constructor for term cmove_xmm.

5179

pub fn constructor_cmove_xmm<C: Context>(

5180

    ctx: &mut C,

5181

    arg0: Type,

5182

    arg1: &CC,

5183

    arg2: &XmmMemAligned,

5184

    arg3: Xmm,

5185

) -> ConsumesFlags {

5186

    let v4 = C::temp_writable_xmm(ctx);

5187

    let v6 = constructor_writable_xmm_to_r_reg(ctx, v4);

5188

    let v5 = MInst::XmmCmove {

5189

        ty: arg0,

5190

        cc: arg1.clone(),

5191

        consequent: arg2.clone(),

5192

        alternative: arg3,

5193

        dst: v4,

5194

};

5195

    let v7 = ConsumesFlags::ConsumesFlagsReturnsReg {

5196

        inst: v5,

5197

        result: v6,

5198

};

5199

    // Rule at src/isa/x64/inst.isle line 2823.

5200

    return v7;

5201

5202

5203

// Generated as internal constructor for term cmove_from_values.

5204

pub fn constructor_cmove_from_values<C: Context>(

5205

    ctx: &mut C,

5206

    arg0: Type,

5207

    arg1: &CC,

5208

    arg2: Value,

5209

    arg3: Value,

5210

) -> ConsumesFlags {

5211

    let v1 = &C::type_register_class(ctx, arg0);

5212

    if let Some(v2) = v1 {

5213

        match v2 {

5214

            &RegisterClass::Gpr {

5215

                single_register: v3,

5216

            } => {

5217

                match v3 {

5218

                    true => {

5219

                        let v26 = &constructor_put_in_gpr_mem(ctx, arg2);

5220

                        let v27 = constructor_put_in_gpr(ctx, arg3);

5221

                        let v28 = &constructor_cmove(ctx, arg0, arg1, v26, v27);

5222

                        // Rule at src/isa/x64/inst.isle line 2854.

5223

                        return v28.clone();

5224

5225

                    false => {

5226

                        if arg0 == I128 {

5227

                            let v7 = C::put_in_regs(ctx, arg2);

5228

                            let v8 = C::put_in_regs(ctx, arg3);

5229

                            let v9 = C::temp_writable_gpr(ctx);

5230

                            let v10 = C::temp_writable_gpr(ctx);

5231

                            let v13 = constructor_value_regs_get_gpr(ctx, v7, 0x0);

5232

                            let v14 = &C::gpr_to_gpr_mem(ctx, v13);

5233

                            let v15 = constructor_value_regs_get_gpr(ctx, v8, 0x0);

5234

                            let v18 = constructor_value_regs_get_gpr(ctx, v7, 0x1);

5235

                            let v19 = &C::gpr_to_gpr_mem(ctx, v18);

5236

                            let v20 = constructor_value_regs_get_gpr(ctx, v8, 0x1);

5237

                            let v22 = constructor_writable_gpr_to_r_reg(ctx, v9);

5238

                            let v23 = constructor_writable_gpr_to_r_reg(ctx, v10);

5239

                            let v24 = C::value_regs(ctx, v22, v23);

5240

                            let v16 = MInst::Cmove {

5241

                                size: OperandSize::Size64,

5242

                                cc: arg1.clone(),

5243

                                consequent: v14.clone(),

5244

                                alternative: v15,

5245

                                dst: v9,

5246

};

5247

                            let v21 = MInst::Cmove {

5248

                                size: OperandSize::Size64,

5249

                                cc: arg1.clone(),

5250

                                consequent: v19.clone(),

5251

                                alternative: v20,

5252

                                dst: v10,

5253

};

5254

                            let v25 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {

5255

                                inst1: v16,

5256

                                inst2: v21,

5257

                                result: v24,

5258

};

5259

                            // Rule at src/isa/x64/inst.isle line 2833.

5260

                            return v25;

5261

5262

5263

                    _ => {}

5264

5265

5266

            &RegisterClass::Xmm => {

5267

                let v29 = &constructor_put_in_xmm_mem_aligned(ctx, arg2);

5268

                let v30 = constructor_put_in_xmm(ctx, arg3);

5269

                let v31 = &constructor_cmove_xmm(ctx, arg0, arg1, v29, v30);

5270

                // Rule at src/isa/x64/inst.isle line 2857.

5271

                return v31.clone();

5272

5273

            _ => {}

5274

5275

5276

    unreachable!(

5277

        "no rule matched for term {} at {}; should it be partial?",

5278

        "cmove_from_values", "src/isa/x64/inst.isle line 2832"

5279

5280

5281

5282

// Generated as internal constructor for term cmove_or.

5283

pub fn constructor_cmove_or<C: Context>(

5284

    ctx: &mut C,

5285

    arg0: Type,

5286

    arg1: &CC,

5287

    arg2: &CC,

5288

    arg3: &GprMem,

5289

    arg4: Gpr,

5290

) -> ConsumesFlags {

5291

    let v5 = C::temp_writable_gpr(ctx);

5292

    let v6 = C::temp_writable_gpr(ctx);

5293

    let v7 = &C::operand_size_of_type_32_64(ctx, arg0);

5294

    let v9 = C::writable_gpr_to_gpr(ctx, v6);

5295

    let v11 = constructor_writable_gpr_to_value_regs(ctx, v5);

5296

    let v8 = MInst::Cmove {

5297

        size: v7.clone(),

5298

        cc: arg1.clone(),

5299

        consequent: arg3.clone(),

5300

        alternative: arg4,

5301

        dst: v6,

5302

};

5303

    let v10 = MInst::Cmove {

5304

        size: v7.clone(),

5305

        cc: arg2.clone(),

5306

        consequent: arg3.clone(),

5307

        alternative: v9,

5308

        dst: v5,

5309

};

5310

    let v12 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {

5311

        inst1: v8,

5312

        inst2: v10,

5313

        result: v11,

5314

};

5315

    // Rule at src/isa/x64/inst.isle line 2864.

5316

    return v12;

5317

5318

5319

// Generated as internal constructor for term cmove_or_xmm.

5320

pub fn constructor_cmove_or_xmm<C: Context>(

5321

    ctx: &mut C,

5322

    arg0: Type,

5323

    arg1: &CC,

5324

    arg2: &CC,

5325

    arg3: &XmmMemAligned,

5326

    arg4: Xmm,

5327

) -> ConsumesFlags {

5328

    let v5 = C::temp_writable_xmm(ctx);

5329

    let v6 = C::temp_writable_xmm(ctx);

5330

    let v8 = C::writable_xmm_to_xmm(ctx, v6);

5331

    let v10 = constructor_writable_xmm_to_value_regs(ctx, v5);

5332

    let v7 = MInst::XmmCmove {

5333

        ty: arg0,

5334

        cc: arg1.clone(),

5335

        consequent: arg3.clone(),

5336

        alternative: arg4,

5337

        dst: v6,

5338

};

5339

    let v9 = MInst::XmmCmove {

5340

        ty: arg0,

5341

        cc: arg2.clone(),

5342

        consequent: arg3.clone(),

5343

        alternative: v8,

5344

        dst: v5,

5345

};

5346

    let v11 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {

5347

        inst1: v7,

5348

        inst2: v9,

5349

        result: v10,

5350

};

5351

    // Rule at src/isa/x64/inst.isle line 2876.

5352

    return v11;

5353

5354

5355

// Generated as internal constructor for term cmove_or_from_values.

5356

pub fn constructor_cmove_or_from_values<C: Context>(

5357

    ctx: &mut C,

5358

    arg0: Type,

5359

    arg1: &CC,

5360

    arg2: &CC,

5361

    arg3: Value,

5362

    arg4: Value,

5363

) -> ConsumesFlags {

5364

    let v1 = &C::type_register_class(ctx, arg0);

5365

    if let Some(v2) = v1 {

5366

        match v2 {

5367

            &RegisterClass::Gpr {

5368

                single_register: v3,

5369

            } => {

5370

                match v3 {

5371

                    true => {

5372

                        let v37 = &constructor_put_in_gpr_mem(ctx, arg3);

5373

                        let v38 = constructor_put_in_gpr(ctx, arg4);

5374

                        let v39 = &constructor_cmove_or(ctx, arg0, arg1, arg2, v37, v38);

5375

                        // Rule at src/isa/x64/inst.isle line 2909.

5376

                        return v39.clone();

5377

5378

                    false => {

5379

                        if arg0 == I128 {

5380

                            let v8 = C::put_in_regs(ctx, arg3);

5381

                            let v9 = C::put_in_regs(ctx, arg4);

5382

                            let v10 = C::temp_writable_gpr(ctx);

5383

                            let v11 = C::temp_writable_gpr(ctx);

5384

                            let v12 = C::temp_writable_gpr(ctx);

5385

                            let v13 = C::temp_writable_gpr(ctx);

5386

                            let v16 = constructor_value_regs_get_gpr(ctx, v8, 0x0);

5387

                            let v17 = &C::gpr_to_gpr_mem(ctx, v16);

5388

                            let v18 = constructor_value_regs_get_gpr(ctx, v9, 0x0);

5389

                            let v20 = constructor_value_regs_get_gpr(ctx, v8, 0x0);

5390

                            let v21 = &C::gpr_to_gpr_mem(ctx, v20);

5391

                            let v22 = C::writable_gpr_to_gpr(ctx, v12);

5392

                            let v25 = constructor_value_regs_get_gpr(ctx, v8, 0x1);

5393

                            let v26 = &C::gpr_to_gpr_mem(ctx, v25);

5394

                            let v27 = constructor_value_regs_get_gpr(ctx, v9, 0x1);

5395

                            let v29 = constructor_value_regs_get_gpr(ctx, v8, 0x1);

5396

                            let v30 = &C::gpr_to_gpr_mem(ctx, v29);

5397

                            let v31 = C::writable_gpr_to_gpr(ctx, v13);

5398

                            let v33 = constructor_writable_gpr_to_r_reg(ctx, v10);

5399

                            let v34 = constructor_writable_gpr_to_r_reg(ctx, v11);

5400

                            let v35 = C::value_regs(ctx, v33, v34);

5401

                            let v19 = MInst::Cmove {

5402

                                size: OperandSize::Size64,

5403

                                cc: arg1.clone(),

5404

                                consequent: v17.clone(),

5405

                                alternative: v18,

5406

                                dst: v12,

5407

};

5408

                            let v23 = MInst::Cmove {

5409

                                size: OperandSize::Size64,

5410

                                cc: arg2.clone(),

5411

                                consequent: v21.clone(),

5412

                                alternative: v22,

5413

                                dst: v10,

5414

};

5415

                            let v28 = MInst::Cmove {

5416

                                size: OperandSize::Size64,

5417

                                cc: arg1.clone(),

5418

                                consequent: v26.clone(),

5419

                                alternative: v27,

5420

                                dst: v13,

5421

};

5422

                            let v32 = MInst::Cmove {

5423

                                size: OperandSize::Size64,

5424

                                cc: arg2.clone(),

5425

                                consequent: v30.clone(),

5426

                                alternative: v31,

5427

                                dst: v11,

5428

};

5429

                            let v36 = ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {

5430

                                inst1: v19,

5431

                                inst2: v23,

5432

                                inst3: v28,

5433

                                inst4: v32,

5434

                                result: v35,

5435

};

5436

                            // Rule at src/isa/x64/inst.isle line 2890.

5437

                            return v36;

5438

5439

5440

                    _ => {}

5441

5442

5443

            &RegisterClass::Xmm => {

5444

                let v40 = &constructor_put_in_xmm_mem_aligned(ctx, arg3);

5445

                let v41 = constructor_put_in_xmm(ctx, arg4);

5446

                let v42 = &constructor_cmove_or_xmm(ctx, arg0, arg1, arg2, v40, v41);

5447

                // Rule at src/isa/x64/inst.isle line 2912.

5448

                return v42.clone();

5449

5450

            _ => {}

5451

5452

5453

    unreachable!(

5454

        "no rule matched for term {} at {}; should it be partial?",

5455

        "cmove_or_from_values", "src/isa/x64/inst.isle line 2889"

5456

5457

5458

5459

// Generated as internal constructor for term x64_setcc.

5460

pub fn constructor_x64_setcc<C: Context>(ctx: &mut C, arg0: &CC) -> ConsumesFlags {

5461

    let v1 = C::temp_writable_gpr(ctx);

5462

    let v3 = constructor_writable_gpr_to_r_reg(ctx, v1);

5463

    let v2 = MInst::Setcc {

5464

        cc: arg0.clone(),

5465

        dst: v1,

5466

};

5467

    let v4 = ConsumesFlags::ConsumesFlagsReturnsReg {

5468

        inst: v2,

5469

        result: v3,

5470

};

5471

    // Rule at src/isa/x64/inst.isle line 2917.

5472

    return v4;

5473

5474

5475

// Generated as internal constructor for term x64_setcc_paired.

5476

pub fn constructor_x64_setcc_paired<C: Context>(ctx: &mut C, arg0: &CC) -> ConsumesFlags {

5477

    let v1 = C::temp_writable_gpr(ctx);

5478

    let v3 = constructor_writable_gpr_to_r_reg(ctx, v1);

5479

    let v2 = MInst::Setcc {

5480

        cc: arg0.clone(),

5481

        dst: v1,

5482

};

5483

    let v4 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {

5484

        inst: v2,

5485

        result: v3,

5486

};

5487

    // Rule at src/isa/x64/inst.isle line 2926.

5488

    return v4;

5489

5490

5491

// Generated as internal constructor for term x64_paddb.

5492

pub fn constructor_x64_paddb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5493

    let v5 = C::use_avx(ctx);

5494

    if v5 == true {

5495

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5496

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpaddb, arg0, v7);

5497

        // Rule at src/isa/x64/inst.isle line 2936.

5498

        return v8;

5499

5500

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5501

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Paddb, arg0, v3);

5502

    // Rule at src/isa/x64/inst.isle line 2934.

5503

    return v4;

5504

5505

5506

// Generated as internal constructor for term x64_paddw.

5507

pub fn constructor_x64_paddw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5508

    let v5 = C::use_avx(ctx);

5509

    if v5 == true {

5510

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5511

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpaddw, arg0, v7);

5512

        // Rule at src/isa/x64/inst.isle line 2944.

5513

        return v8;

5514

5515

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5516

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Paddw, arg0, v3);

5517

    // Rule at src/isa/x64/inst.isle line 2942.

5518

    return v4;

5519

5520

5521

// Generated as internal constructor for term x64_paddd.

5522

pub fn constructor_x64_paddd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5523

    let v5 = C::use_avx(ctx);

5524

    if v5 == true {

5525

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5526

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpaddd, arg0, v7);

5527

        // Rule at src/isa/x64/inst.isle line 2952.

5528

        return v8;

5529

5530

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5531

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Paddd, arg0, v3);

5532

    // Rule at src/isa/x64/inst.isle line 2950.

5533

    return v4;

5534

5535

5536

// Generated as internal constructor for term x64_paddq.

5537

pub fn constructor_x64_paddq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5538

    let v5 = C::use_avx(ctx);

5539

    if v5 == true {

5540

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5541

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpaddq, arg0, v7);

5542

        // Rule at src/isa/x64/inst.isle line 2960.

5543

        return v8;

5544

5545

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5546

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Paddq, arg0, v3);

5547

    // Rule at src/isa/x64/inst.isle line 2958.

5548

    return v4;

5549

5550

5551

// Generated as internal constructor for term x64_paddsb.

5552

pub fn constructor_x64_paddsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5553

    let v5 = C::use_avx(ctx);

5554

    if v5 == true {

5555

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5556

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpaddsb, arg0, v7);

5557

        // Rule at src/isa/x64/inst.isle line 2968.

5558

        return v8;

5559

5560

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5561

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Paddsb, arg0, v3);

5562

    // Rule at src/isa/x64/inst.isle line 2966.

5563

    return v4;

5564

5565

5566

// Generated as internal constructor for term x64_paddsw.

5567

pub fn constructor_x64_paddsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5568

    let v5 = C::use_avx(ctx);

5569

    if v5 == true {

5570

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5571

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpaddsw, arg0, v7);

5572

        // Rule at src/isa/x64/inst.isle line 2976.

5573

        return v8;

5574

5575

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5576

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Paddsw, arg0, v3);

5577

    // Rule at src/isa/x64/inst.isle line 2974.

5578

    return v4;

5579

5580

5581

// Generated as internal constructor for term x64_phaddw.

5582

pub fn constructor_x64_phaddw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5583

    let v5 = C::use_avx(ctx);

5584

    if v5 == true {

5585

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5586

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vphaddw, arg0, v7);

5587

        // Rule at src/isa/x64/inst.isle line 2984.

5588

        return v8;

5589

5590

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5591

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Phaddw, arg0, v3);

5592

    // Rule at src/isa/x64/inst.isle line 2982.

5593

    return v4;

5594

5595

5596

// Generated as internal constructor for term x64_phaddd.

5597

pub fn constructor_x64_phaddd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5598

    let v5 = C::use_avx(ctx);

5599

    if v5 == true {

5600

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5601

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vphaddd, arg0, v7);

5602

        // Rule at src/isa/x64/inst.isle line 2992.

5603

        return v8;

5604

5605

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5606

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Phaddd, arg0, v3);

5607

    // Rule at src/isa/x64/inst.isle line 2990.

5608

    return v4;

5609

5610

5611

// Generated as internal constructor for term x64_paddusb.

5612

pub fn constructor_x64_paddusb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5613

    let v5 = C::use_avx(ctx);

5614

    if v5 == true {

5615

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5616

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpaddusb, arg0, v7);

5617

        // Rule at src/isa/x64/inst.isle line 3000.

5618

        return v8;

5619

5620

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5621

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Paddusb, arg0, v3);

5622

    // Rule at src/isa/x64/inst.isle line 2998.

5623

    return v4;

5624

5625

5626

// Generated as internal constructor for term x64_paddusw.

5627

pub fn constructor_x64_paddusw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5628

    let v5 = C::use_avx(ctx);

5629

    if v5 == true {

5630

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5631

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpaddusw, arg0, v7);

5632

        // Rule at src/isa/x64/inst.isle line 3008.

5633

        return v8;

5634

5635

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5636

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Paddusw, arg0, v3);

5637

    // Rule at src/isa/x64/inst.isle line 3006.

5638

    return v4;

5639

5640

5641

// Generated as internal constructor for term x64_psubb.

5642

pub fn constructor_x64_psubb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5643

    let v5 = C::use_avx(ctx);

5644

    if v5 == true {

5645

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5646

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsubb, arg0, v7);

5647

        // Rule at src/isa/x64/inst.isle line 3016.

5648

        return v8;

5649

5650

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5651

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Psubb, arg0, v3);

5652

    // Rule at src/isa/x64/inst.isle line 3014.

5653

    return v4;

5654

5655

5656

// Generated as internal constructor for term x64_psubw.

5657

pub fn constructor_x64_psubw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5658

    let v5 = C::use_avx(ctx);

5659

    if v5 == true {

5660

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5661

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsubw, arg0, v7);

5662

        // Rule at src/isa/x64/inst.isle line 3024.

5663

        return v8;

5664

5665

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5666

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Psubw, arg0, v3);

5667

    // Rule at src/isa/x64/inst.isle line 3022.

5668

    return v4;

5669

5670

5671

// Generated as internal constructor for term x64_psubd.

5672

pub fn constructor_x64_psubd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5673

    let v5 = C::use_avx(ctx);

5674

    if v5 == true {

5675

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5676

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsubd, arg0, v7);

5677

        // Rule at src/isa/x64/inst.isle line 3032.

5678

        return v8;

5679

5680

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5681

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Psubd, arg0, v3);

5682

    // Rule at src/isa/x64/inst.isle line 3030.

5683

    return v4;

5684

5685

5686

// Generated as internal constructor for term x64_psubq.

5687

pub fn constructor_x64_psubq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5688

    let v5 = C::use_avx(ctx);

5689

    if v5 == true {

5690

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5691

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsubq, arg0, v7);

5692

        // Rule at src/isa/x64/inst.isle line 3040.

5693

        return v8;

5694

5695

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5696

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Psubq, arg0, v3);

5697

    // Rule at src/isa/x64/inst.isle line 3038.

5698

    return v4;

5699

5700

5701

// Generated as internal constructor for term x64_psubsb.

5702

pub fn constructor_x64_psubsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5703

    let v5 = C::use_avx(ctx);

5704

    if v5 == true {

5705

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5706

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsubsb, arg0, v7);

5707

        // Rule at src/isa/x64/inst.isle line 3048.

5708

        return v8;

5709

5710

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5711

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Psubsb, arg0, v3);

5712

    // Rule at src/isa/x64/inst.isle line 3046.

5713

    return v4;

5714

5715

5716

// Generated as internal constructor for term x64_psubsw.

5717

pub fn constructor_x64_psubsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5718

    let v5 = C::use_avx(ctx);

5719

    if v5 == true {

5720

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5721

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsubsw, arg0, v7);

5722

        // Rule at src/isa/x64/inst.isle line 3056.

5723

        return v8;

5724

5725

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5726

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Psubsw, arg0, v3);

5727

    // Rule at src/isa/x64/inst.isle line 3054.

5728

    return v4;

5729

5730

5731

// Generated as internal constructor for term x64_psubusb.

5732

pub fn constructor_x64_psubusb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5733

    let v5 = C::use_avx(ctx);

5734

    if v5 == true {

5735

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5736

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsubusb, arg0, v7);

5737

        // Rule at src/isa/x64/inst.isle line 3064.

5738

        return v8;

5739

5740

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5741

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Psubusb, arg0, v3);

5742

    // Rule at src/isa/x64/inst.isle line 3062.

5743

    return v4;

5744

5745

5746

// Generated as internal constructor for term x64_psubusw.

5747

pub fn constructor_x64_psubusw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5748

    let v5 = C::use_avx(ctx);

5749

    if v5 == true {

5750

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5751

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsubusw, arg0, v7);

5752

        // Rule at src/isa/x64/inst.isle line 3072.

5753

        return v8;

5754

5755

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5756

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Psubusw, arg0, v3);

5757

    // Rule at src/isa/x64/inst.isle line 3070.

5758

    return v4;

5759

5760

5761

// Generated as internal constructor for term x64_pavgb.

5762

pub fn constructor_x64_pavgb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5763

    let v5 = C::use_avx(ctx);

5764

    if v5 == true {

5765

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5766

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpavgb, arg0, v7);

5767

        // Rule at src/isa/x64/inst.isle line 3080.

5768

        return v8;

5769

5770

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5771

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pavgb, arg0, v3);

5772

    // Rule at src/isa/x64/inst.isle line 3078.

5773

    return v4;

5774

5775

5776

// Generated as internal constructor for term x64_pavgw.

5777

pub fn constructor_x64_pavgw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5778

    let v5 = C::use_avx(ctx);

5779

    if v5 == true {

5780

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5781

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpavgw, arg0, v7);

5782

        // Rule at src/isa/x64/inst.isle line 3088.

5783

        return v8;

5784

5785

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5786

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pavgw, arg0, v3);

5787

    // Rule at src/isa/x64/inst.isle line 3086.

5788

    return v4;

5789

5790

5791

// Generated as internal constructor for term x64_pand.

5792

pub fn constructor_x64_pand<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5793

    let v5 = C::use_avx(ctx);

5794

    if v5 == true {

5795

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5796

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpand, arg0, v7);

5797

        // Rule at src/isa/x64/inst.isle line 3096.

5798

        return v8;

5799

5800

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5801

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pand, arg0, v3);

5802

    // Rule at src/isa/x64/inst.isle line 3094.

5803

    return v4;

5804

5805

5806

// Generated as internal constructor for term x64_andps.

5807

pub fn constructor_x64_andps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5808

    let v5 = C::use_avx(ctx);

5809

    if v5 == true {

5810

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5811

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vandps, arg0, v7);

5812

        // Rule at src/isa/x64/inst.isle line 3104.

5813

        return v8;

5814

5815

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5816

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Andps, arg0, v3);

5817

    // Rule at src/isa/x64/inst.isle line 3102.

5818

    return v4;

5819

5820

5821

// Generated as internal constructor for term x64_andpd.

5822

pub fn constructor_x64_andpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5823

    let v5 = C::use_avx(ctx);

5824

    if v5 == true {

5825

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5826

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vandpd, arg0, v7);

5827

        // Rule at src/isa/x64/inst.isle line 3112.

5828

        return v8;

5829

5830

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5831

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Andpd, arg0, v3);

5832

    // Rule at src/isa/x64/inst.isle line 3110.

5833

    return v4;

5834

5835

5836

// Generated as internal constructor for term x64_por.

5837

pub fn constructor_x64_por<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5838

    let v5 = C::use_avx(ctx);

5839

    if v5 == true {

5840

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5841

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpor, arg0, v7);

5842

        // Rule at src/isa/x64/inst.isle line 3120.

5843

        return v8;

5844

5845

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5846

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Por, arg0, v3);

5847

    // Rule at src/isa/x64/inst.isle line 3118.

5848

    return v4;

5849

5850

5851

// Generated as internal constructor for term x64_orps.

5852

pub fn constructor_x64_orps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5853

    let v5 = C::use_avx(ctx);

5854

    if v5 == true {

5855

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5856

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vorps, arg0, v7);

5857

        // Rule at src/isa/x64/inst.isle line 3128.

5858

        return v8;

5859

5860

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5861

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Orps, arg0, v3);

5862

    // Rule at src/isa/x64/inst.isle line 3126.

5863

    return v4;

5864

5865

5866

// Generated as internal constructor for term x64_orpd.

5867

pub fn constructor_x64_orpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5868

    let v5 = C::use_avx(ctx);

5869

    if v5 == true {

5870

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5871

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vorpd, arg0, v7);

5872

        // Rule at src/isa/x64/inst.isle line 3136.

5873

        return v8;

5874

5875

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5876

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Orpd, arg0, v3);

5877

    // Rule at src/isa/x64/inst.isle line 3134.

5878

    return v4;

5879

5880

5881

// Generated as internal constructor for term x64_pxor.

5882

pub fn constructor_x64_pxor<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5883

    let v5 = C::use_avx(ctx);

5884

    if v5 == true {

5885

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5886

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpxor, arg0, v7);

5887

        // Rule at src/isa/x64/inst.isle line 3144.

5888

        return v8;

5889

5890

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5891

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pxor, arg0, v3);

5892

    // Rule at src/isa/x64/inst.isle line 3142.

5893

    return v4;

5894

5895

5896

// Generated as internal constructor for term x64_xorps.

5897

pub fn constructor_x64_xorps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5898

    let v5 = C::use_avx(ctx);

5899

    if v5 == true {

5900

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5901

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vxorps, arg0, v7);

5902

        // Rule at src/isa/x64/inst.isle line 3152.

5903

        return v8;

5904

5905

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5906

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Xorps, arg0, v3);

5907

    // Rule at src/isa/x64/inst.isle line 3150.

5908

    return v4;

5909

5910

5911

// Generated as internal constructor for term x64_xorpd.

5912

pub fn constructor_x64_xorpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5913

    let v5 = C::use_avx(ctx);

5914

    if v5 == true {

5915

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5916

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vxorpd, arg0, v7);

5917

        // Rule at src/isa/x64/inst.isle line 3160.

5918

        return v8;

5919

5920

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5921

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Xorpd, arg0, v3);

5922

    // Rule at src/isa/x64/inst.isle line 3158.

5923

    return v4;

5924

5925

5926

// Generated as internal constructor for term x64_pmullw.

5927

pub fn constructor_x64_pmullw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5928

    let v5 = C::use_avx(ctx);

5929

    if v5 == true {

5930

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5931

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmullw, arg0, v7);

5932

        // Rule at src/isa/x64/inst.isle line 3168.

5933

        return v8;

5934

5935

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5936

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmullw, arg0, v3);

5937

    // Rule at src/isa/x64/inst.isle line 3166.

5938

    return v4;

5939

5940

5941

// Generated as internal constructor for term x64_pmulld.

5942

pub fn constructor_x64_pmulld<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5943

    let v5 = C::use_avx(ctx);

5944

    if v5 == true {

5945

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5946

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmulld, arg0, v7);

5947

        // Rule at src/isa/x64/inst.isle line 3176.

5948

        return v8;

5949

5950

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5951

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmulld, arg0, v3);

5952

    // Rule at src/isa/x64/inst.isle line 3174.

5953

    return v4;

5954

5955

5956

// Generated as internal constructor for term x64_pmulhw.

5957

pub fn constructor_x64_pmulhw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5958

    let v5 = C::use_avx(ctx);

5959

    if v5 == true {

5960

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5961

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmulhw, arg0, v7);

5962

        // Rule at src/isa/x64/inst.isle line 3184.

5963

        return v8;

5964

5965

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5966

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmulhw, arg0, v3);

5967

    // Rule at src/isa/x64/inst.isle line 3182.

5968

    return v4;

5969

5970

5971

// Generated as internal constructor for term x64_pmulhrsw.

5972

pub fn constructor_x64_pmulhrsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5973

    let v5 = C::use_avx(ctx);

5974

    if v5 == true {

5975

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5976

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmulhrsw, arg0, v7);

5977

        // Rule at src/isa/x64/inst.isle line 3192.

5978

        return v8;

5979

5980

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5981

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmulhrsw, arg0, v3);

5982

    // Rule at src/isa/x64/inst.isle line 3190.

5983

    return v4;

5984

5985

5986

// Generated as internal constructor for term x64_pmulhuw.

5987

pub fn constructor_x64_pmulhuw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

5988

    let v5 = C::use_avx(ctx);

5989

    if v5 == true {

5990

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

5991

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmulhuw, arg0, v7);

5992

        // Rule at src/isa/x64/inst.isle line 3200.

5993

        return v8;

5994

5995

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

5996

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmulhuw, arg0, v3);

5997

    // Rule at src/isa/x64/inst.isle line 3198.

5998

    return v4;

5999

6000

6001

// Generated as internal constructor for term x64_pmuldq.

6002

pub fn constructor_x64_pmuldq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6003

    let v5 = C::use_avx(ctx);

6004

    if v5 == true {

6005

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6006

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmuldq, arg0, v7);

6007

        // Rule at src/isa/x64/inst.isle line 3208.

6008

        return v8;

6009

6010

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6011

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmuldq, arg0, v3);

6012

    // Rule at src/isa/x64/inst.isle line 3206.

6013

    return v4;

6014

6015

6016

// Generated as internal constructor for term x64_pmuludq.

6017

pub fn constructor_x64_pmuludq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6018

    let v5 = C::use_avx(ctx);

6019

    if v5 == true {

6020

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6021

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmuludq, arg0, v7);

6022

        // Rule at src/isa/x64/inst.isle line 3216.

6023

        return v8;

6024

6025

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6026

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmuludq, arg0, v3);

6027

    // Rule at src/isa/x64/inst.isle line 3214.

6028

    return v4;

6029

6030

6031

// Generated as internal constructor for term x64_punpckhwd.

6032

pub fn constructor_x64_punpckhwd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6033

    let v5 = C::use_avx(ctx);

6034

    if v5 == true {

6035

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6036

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpunpckhwd, arg0, v7);

6037

        // Rule at src/isa/x64/inst.isle line 3224.

6038

        return v8;

6039

6040

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6041

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Punpckhwd, arg0, v3);

6042

    // Rule at src/isa/x64/inst.isle line 3222.

6043

    return v4;

6044

6045

6046

// Generated as internal constructor for term x64_punpcklwd.

6047

pub fn constructor_x64_punpcklwd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6048

    let v5 = C::use_avx(ctx);

6049

    if v5 == true {

6050

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6051

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpunpcklwd, arg0, v7);

6052

        // Rule at src/isa/x64/inst.isle line 3232.

6053

        return v8;

6054

6055

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6056

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Punpcklwd, arg0, v3);

6057

    // Rule at src/isa/x64/inst.isle line 3230.

6058

    return v4;

6059

6060

6061

// Generated as internal constructor for term x64_punpckldq.

6062

pub fn constructor_x64_punpckldq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6063

    let v5 = C::use_avx(ctx);

6064

    if v5 == true {

6065

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6066

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpunpckldq, arg0, v7);

6067

        // Rule at src/isa/x64/inst.isle line 3240.

6068

        return v8;

6069

6070

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6071

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Punpckldq, arg0, v3);

6072

    // Rule at src/isa/x64/inst.isle line 3238.

6073

    return v4;

6074

6075

6076

// Generated as internal constructor for term x64_punpckhdq.

6077

pub fn constructor_x64_punpckhdq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6078

    let v5 = C::use_avx(ctx);

6079

    if v5 == true {

6080

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6081

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpunpckhdq, arg0, v7);

6082

        // Rule at src/isa/x64/inst.isle line 3248.

6083

        return v8;

6084

6085

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6086

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Punpckhdq, arg0, v3);

6087

    // Rule at src/isa/x64/inst.isle line 3246.

6088

    return v4;

6089

6090

6091

// Generated as internal constructor for term x64_punpcklqdq.

6092

pub fn constructor_x64_punpcklqdq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6093

    let v5 = C::use_avx(ctx);

6094

    if v5 == true {

6095

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6096

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpunpcklqdq, arg0, v7);

6097

        // Rule at src/isa/x64/inst.isle line 3256.

6098

        return v8;

6099

6100

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6101

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Punpcklqdq, arg0, v3);

6102

    // Rule at src/isa/x64/inst.isle line 3254.

6103

    return v4;

6104

6105

6106

// Generated as internal constructor for term x64_punpckhqdq.

6107

pub fn constructor_x64_punpckhqdq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6108

    let v5 = C::use_avx(ctx);

6109

    if v5 == true {

6110

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6111

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpunpckhqdq, arg0, v7);

6112

        // Rule at src/isa/x64/inst.isle line 3264.

6113

        return v8;

6114

6115

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6116

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Punpckhqdq, arg0, v3);

6117

    // Rule at src/isa/x64/inst.isle line 3262.

6118

    return v4;

6119

6120

6121

// Generated as internal constructor for term x64_unpcklps.

6122

pub fn constructor_x64_unpcklps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6123

    let v5 = C::use_avx(ctx);

6124

    if v5 == true {

6125

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6126

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vunpcklps, arg0, v7);

6127

        // Rule at src/isa/x64/inst.isle line 3272.

6128

        return v8;

6129

6130

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6131

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Unpcklps, arg0, v3);

6132

    // Rule at src/isa/x64/inst.isle line 3270.

6133

    return v4;

6134

6135

6136

// Generated as internal constructor for term x64_unpckhps.

6137

pub fn constructor_x64_unpckhps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6138

    let v5 = C::use_avx(ctx);

6139

    if v5 == true {

6140

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6141

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vunpckhps, arg0, v7);

6142

        // Rule at src/isa/x64/inst.isle line 3280.

6143

        return v8;

6144

6145

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6146

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Unpckhps, arg0, v3);

6147

    // Rule at src/isa/x64/inst.isle line 3278.

6148

    return v4;

6149

6150

6151

// Generated as internal constructor for term x64_andnps.

6152

pub fn constructor_x64_andnps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6153

    let v5 = C::use_avx(ctx);

6154

    if v5 == true {

6155

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6156

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vandnps, arg0, v7);

6157

        // Rule at src/isa/x64/inst.isle line 3288.

6158

        return v8;

6159

6160

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6161

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Andnps, arg0, v3);

6162

    // Rule at src/isa/x64/inst.isle line 3286.

6163

    return v4;

6164

6165

6166

// Generated as internal constructor for term x64_andnpd.

6167

pub fn constructor_x64_andnpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6168

    let v5 = C::use_avx(ctx);

6169

    if v5 == true {

6170

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6171

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vandnpd, arg0, v7);

6172

        // Rule at src/isa/x64/inst.isle line 3296.

6173

        return v8;

6174

6175

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6176

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Andnpd, arg0, v3);

6177

    // Rule at src/isa/x64/inst.isle line 3294.

6178

    return v4;

6179

6180

6181

// Generated as internal constructor for term x64_pandn.

6182

pub fn constructor_x64_pandn<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6183

    let v5 = C::use_avx(ctx);

6184

    if v5 == true {

6185

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6186

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpandn, arg0, v7);

6187

        // Rule at src/isa/x64/inst.isle line 3304.

6188

        return v8;

6189

6190

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6191

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pandn, arg0, v3);

6192

    // Rule at src/isa/x64/inst.isle line 3302.

6193

    return v4;

6194

6195

6196

// Generated as internal constructor for term x64_addss.

6197

pub fn constructor_x64_addss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6198

    let v4 = C::use_avx(ctx);

6199

    if v4 == true {

6200

        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6201

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vaddss, arg0, v6);

6202

        // Rule at src/isa/x64/inst.isle line 3312.

6203

        return v7;

6204

6205

    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Addss, arg0, arg1);

6206

    // Rule at src/isa/x64/inst.isle line 3310.

6207

    return v3;

6208

6209

6210

// Generated as internal constructor for term x64_addsd.

6211

pub fn constructor_x64_addsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6212

    let v4 = C::use_avx(ctx);

6213

    if v4 == true {

6214

        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6215

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vaddsd, arg0, v6);

6216

        // Rule at src/isa/x64/inst.isle line 3320.

6217

        return v7;

6218

6219

    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Addsd, arg0, arg1);

6220

    // Rule at src/isa/x64/inst.isle line 3318.

6221

    return v3;

6222

6223

6224

// Generated as internal constructor for term x64_addps.

6225

pub fn constructor_x64_addps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6226

    let v5 = C::use_avx(ctx);

6227

    if v5 == true {

6228

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6229

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vaddps, arg0, v7);

6230

        // Rule at src/isa/x64/inst.isle line 3328.

6231

        return v8;

6232

6233

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6234

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Addps, arg0, v3);

6235

    // Rule at src/isa/x64/inst.isle line 3326.

6236

    return v4;

6237

6238

6239

// Generated as internal constructor for term x64_addpd.

6240

pub fn constructor_x64_addpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6241

    let v5 = C::use_avx(ctx);

6242

    if v5 == true {

6243

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6244

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vaddpd, arg0, v7);

6245

        // Rule at src/isa/x64/inst.isle line 3336.

6246

        return v8;

6247

6248

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6249

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Addpd, arg0, v3);

6250

    // Rule at src/isa/x64/inst.isle line 3334.

6251

    return v4;

6252

6253

6254

// Generated as internal constructor for term x64_subss.

6255

pub fn constructor_x64_subss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6256

    let v4 = C::use_avx(ctx);

6257

    if v4 == true {

6258

        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6259

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vsubss, arg0, v6);

6260

        // Rule at src/isa/x64/inst.isle line 3344.

6261

        return v7;

6262

6263

    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Subss, arg0, arg1);

6264

    // Rule at src/isa/x64/inst.isle line 3342.

6265

    return v3;

6266

6267

6268

// Generated as internal constructor for term x64_subsd.

6269

pub fn constructor_x64_subsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6270

    let v4 = C::use_avx(ctx);

6271

    if v4 == true {

6272

        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6273

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vsubsd, arg0, v6);

6274

        // Rule at src/isa/x64/inst.isle line 3352.

6275

        return v7;

6276

6277

    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Subsd, arg0, arg1);

6278

    // Rule at src/isa/x64/inst.isle line 3350.

6279

    return v3;

6280

6281

6282

// Generated as internal constructor for term x64_subps.

6283

pub fn constructor_x64_subps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6284

    let v5 = C::use_avx(ctx);

6285

    if v5 == true {

6286

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6287

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vsubps, arg0, v7);

6288

        // Rule at src/isa/x64/inst.isle line 3360.

6289

        return v8;

6290

6291

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6292

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Subps, arg0, v3);

6293

    // Rule at src/isa/x64/inst.isle line 3358.

6294

    return v4;

6295

6296

6297

// Generated as internal constructor for term x64_subpd.

6298

pub fn constructor_x64_subpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6299

    let v5 = C::use_avx(ctx);

6300

    if v5 == true {

6301

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6302

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vsubpd, arg0, v7);

6303

        // Rule at src/isa/x64/inst.isle line 3368.

6304

        return v8;

6305

6306

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6307

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Subpd, arg0, v3);

6308

    // Rule at src/isa/x64/inst.isle line 3366.

6309

    return v4;

6310

6311

6312

// Generated as internal constructor for term x64_mulss.

6313

pub fn constructor_x64_mulss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6314

    let v4 = C::use_avx(ctx);

6315

    if v4 == true {

6316

        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6317

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmulss, arg0, v6);

6318

        // Rule at src/isa/x64/inst.isle line 3376.

6319

        return v7;

6320

6321

    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Mulss, arg0, arg1);

6322

    // Rule at src/isa/x64/inst.isle line 3374.

6323

    return v3;

6324

6325

6326

// Generated as internal constructor for term x64_mulsd.

6327

pub fn constructor_x64_mulsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6328

    let v4 = C::use_avx(ctx);

6329

    if v4 == true {

6330

        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6331

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmulsd, arg0, v6);

6332

        // Rule at src/isa/x64/inst.isle line 3384.

6333

        return v7;

6334

6335

    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Mulsd, arg0, arg1);

6336

    // Rule at src/isa/x64/inst.isle line 3382.

6337

    return v3;

6338

6339

6340

// Generated as internal constructor for term x64_mulps.

6341

pub fn constructor_x64_mulps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6342

    let v5 = C::use_avx(ctx);

6343

    if v5 == true {

6344

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6345

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmulps, arg0, v7);

6346

        // Rule at src/isa/x64/inst.isle line 3392.

6347

        return v8;

6348

6349

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6350

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Mulps, arg0, v3);

6351

    // Rule at src/isa/x64/inst.isle line 3390.

6352

    return v4;

6353

6354

6355

// Generated as internal constructor for term x64_mulpd.

6356

pub fn constructor_x64_mulpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6357

    let v5 = C::use_avx(ctx);

6358

    if v5 == true {

6359

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6360

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmulpd, arg0, v7);

6361

        // Rule at src/isa/x64/inst.isle line 3400.

6362

        return v8;

6363

6364

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6365

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Mulpd, arg0, v3);

6366

    // Rule at src/isa/x64/inst.isle line 3398.

6367

    return v4;

6368

6369

6370

// Generated as internal constructor for term x64_divss.

6371

pub fn constructor_x64_divss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6372

    let v4 = C::use_avx(ctx);

6373

    if v4 == true {

6374

        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6375

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vdivss, arg0, v6);

6376

        // Rule at src/isa/x64/inst.isle line 3408.

6377

        return v7;

6378

6379

    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Divss, arg0, arg1);

6380

    // Rule at src/isa/x64/inst.isle line 3406.

6381

    return v3;

6382

6383

6384

// Generated as internal constructor for term x64_divsd.

6385

pub fn constructor_x64_divsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6386

    let v4 = C::use_avx(ctx);

6387

    if v4 == true {

6388

        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6389

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vdivsd, arg0, v6);

6390

        // Rule at src/isa/x64/inst.isle line 3416.

6391

        return v7;

6392

6393

    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Divsd, arg0, arg1);

6394

    // Rule at src/isa/x64/inst.isle line 3414.

6395

    return v3;

6396

6397

6398

// Generated as internal constructor for term x64_divps.

6399

pub fn constructor_x64_divps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6400

    let v5 = C::use_avx(ctx);

6401

    if v5 == true {

6402

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6403

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vdivps, arg0, v7);

6404

        // Rule at src/isa/x64/inst.isle line 3424.

6405

        return v8;

6406

6407

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6408

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Divps, arg0, v3);

6409

    // Rule at src/isa/x64/inst.isle line 3422.

6410

    return v4;

6411

6412

6413

// Generated as internal constructor for term x64_divpd.

6414

pub fn constructor_x64_divpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6415

    let v5 = C::use_avx(ctx);

6416

    if v5 == true {

6417

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6418

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vdivpd, arg0, v7);

6419

        // Rule at src/isa/x64/inst.isle line 3432.

6420

        return v8;

6421

6422

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6423

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Divpd, arg0, v3);

6424

    // Rule at src/isa/x64/inst.isle line 3430.

6425

    return v4;

6426

6427

6428

// Generated as internal constructor for term x64_blendvpd.

6429

pub fn constructor_x64_blendvpd<C: Context>(

6430

    ctx: &mut C,

6431

    arg0: Xmm,

6432

    arg1: &XmmMem,

6433

    arg2: Xmm,

6434

) -> Xmm {

6435

    let v6 = C::use_avx(ctx);

6436

    if v6 == true {

6437

        let v8 = constructor_xmm_rmr_blend_vex(ctx, &AvxOpcode::Vblendvpd, arg0, arg1, arg2);

6438

        // Rule at src/isa/x64/inst.isle line 3440.

6439

        return v8;

6440

6441

    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6442

    let v5 = constructor_xmm_rm_r_blend(ctx, &SseOpcode::Blendvpd, arg0, v4, arg2);

6443

    // Rule at src/isa/x64/inst.isle line 3438.

6444

    return v5;

6445

6446

6447

// Generated as internal constructor for term x64_blendvps.

6448

pub fn constructor_x64_blendvps<C: Context>(

6449

    ctx: &mut C,

6450

    arg0: Xmm,

6451

    arg1: &XmmMem,

6452

    arg2: Xmm,

6453

) -> Xmm {

6454

    let v6 = C::use_avx(ctx);

6455

    if v6 == true {

6456

        let v8 = constructor_xmm_rmr_blend_vex(ctx, &AvxOpcode::Vblendvps, arg0, arg1, arg2);

6457

        // Rule at src/isa/x64/inst.isle line 3448.

6458

        return v8;

6459

6460

    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6461

    let v5 = constructor_xmm_rm_r_blend(ctx, &SseOpcode::Blendvps, arg0, v4, arg2);

6462

    // Rule at src/isa/x64/inst.isle line 3446.

6463

    return v5;

6464

6465

6466

// Generated as internal constructor for term x64_pblendvb.

6467

pub fn constructor_x64_pblendvb<C: Context>(

6468

    ctx: &mut C,

6469

    arg0: Xmm,

6470

    arg1: &XmmMem,

6471

    arg2: Xmm,

6472

) -> Xmm {

6473

    let v6 = C::use_avx(ctx);

6474

    if v6 == true {

6475

        let v8 = constructor_xmm_rmr_blend_vex(ctx, &AvxOpcode::Vpblendvb, arg0, arg1, arg2);

6476

        // Rule at src/isa/x64/inst.isle line 3456.

6477

        return v8;

6478

6479

    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6480

    let v5 = constructor_xmm_rm_r_blend(ctx, &SseOpcode::Pblendvb, arg0, v4, arg2);

6481

    // Rule at src/isa/x64/inst.isle line 3454.

6482

    return v5;

6483

6484

6485

// Generated as internal constructor for term x64_pblendw.

6486

pub fn constructor_x64_pblendw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> Xmm {

6487

    let v8 = C::use_avx(ctx);

6488

    if v8 == true {

6489

        let v10 = constructor_xmm_rmr_imm_vex(ctx, &AvxOpcode::Vpblendw, arg0, arg1, arg2);

6490

        // Rule at src/isa/x64/inst.isle line 3464.

6491

        return v10;

6492

6493

    let v4 = C::xmm_to_reg(ctx, arg0);

6494

    let v5 = &C::xmm_mem_to_reg_mem(ctx, arg1);

6495

    let v7 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Pblendw, v4, v5, arg2, &OperandSize::Size32);

6496

    // Rule at src/isa/x64/inst.isle line 3462.

6497

    return v7;

6498

6499

6500

// Generated as internal constructor for term x64_movsd_regmove.

6501

pub fn constructor_x64_movsd_regmove<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Xmm {

6502

    let v5 = C::use_avx(ctx);

6503

    if v5 == true {

6504

        let v7 = &C::xmm_to_xmm_mem_imm(ctx, arg1);

6505

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmovsd, arg0, v7);

6506

        // Rule at src/isa/x64/inst.isle line 3479.

6507

        return v8;

6508

6509

    let v3 = &C::xmm_to_xmm_mem(ctx, arg1);

6510

    let v4 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Movsd, arg0, v3);

6511

    // Rule at src/isa/x64/inst.isle line 3477.

6512

    return v4;

6513

6514

6515

// Generated as internal constructor for term x64_movss_regmove.

6516

pub fn constructor_x64_movss_regmove<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Xmm {

6517

    let v5 = C::use_avx(ctx);

6518

    if v5 == true {

6519

        let v7 = &C::xmm_to_xmm_mem_imm(ctx, arg1);

6520

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmovss, arg0, v7);

6521

        // Rule at src/isa/x64/inst.isle line 3486.

6522

        return v8;

6523

6524

    let v3 = &C::xmm_to_xmm_mem(ctx, arg1);

6525

    let v4 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Movss, arg0, v3);

6526

    // Rule at src/isa/x64/inst.isle line 3484.

6527

    return v4;

6528

6529

6530

// Generated as internal constructor for term x64_movlhps.

6531

pub fn constructor_x64_movlhps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6532

    let v5 = C::use_avx(ctx);

6533

    if v5 == true {

6534

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6535

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmovlhps, arg0, v7);

6536

        // Rule at src/isa/x64/inst.isle line 3494.

6537

        return v8;

6538

6539

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6540

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Movlhps, arg0, v3);

6541

    // Rule at src/isa/x64/inst.isle line 3492.

6542

    return v4;

6543

6544

6545

// Generated as internal constructor for term x64_pmaxs.

6546

pub fn constructor_x64_pmaxs<C: Context>(ctx: &mut C, arg0: Type, arg1: Xmm, arg2: &XmmMem) -> Xmm {

6547

    match arg0 {

6548

        I8X16 => {

6549

            let v3 = constructor_x64_pmaxsb(ctx, arg1, arg2);

6550

            // Rule at src/isa/x64/inst.isle line 3500.

6551

            return v3;

6552

6553

        I16X8 => {

6554

            let v4 = constructor_x64_pmaxsw(ctx, arg1, arg2);

6555

            // Rule at src/isa/x64/inst.isle line 3501.

6556

            return v4;

6557

6558

        I32X4 => {

6559

            let v5 = constructor_x64_pmaxsd(ctx, arg1, arg2);

6560

            // Rule at src/isa/x64/inst.isle line 3502.

6561

            return v5;

6562

6563

        _ => {}

6564

6565

    unreachable!(

6566

        "no rule matched for term {} at {}; should it be partial?",

6567

        "x64_pmaxs", "src/isa/x64/inst.isle line 3499"

6568

6569

6570

6571

// Generated as internal constructor for term x64_pmaxsb.

6572

pub fn constructor_x64_pmaxsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6573

    let v5 = C::use_avx(ctx);

6574

    if v5 == true {

6575

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6576

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmaxsb, arg0, v7);

6577

        // Rule at src/isa/x64/inst.isle line 3506.

6578

        return v8;

6579

6580

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6581

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmaxsb, arg0, v3);

6582

    // Rule at src/isa/x64/inst.isle line 3505.

6583

    return v4;

6584

6585

6586

// Generated as internal constructor for term x64_pmaxsw.

6587

pub fn constructor_x64_pmaxsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6588

    let v5 = C::use_avx(ctx);

6589

    if v5 == true {

6590

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6591

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmaxsw, arg0, v7);

6592

        // Rule at src/isa/x64/inst.isle line 3511.

6593

        return v8;

6594

6595

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6596

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmaxsw, arg0, v3);

6597

    // Rule at src/isa/x64/inst.isle line 3510.

6598

    return v4;

6599

6600

6601

// Generated as internal constructor for term x64_pmaxsd.

6602

pub fn constructor_x64_pmaxsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6603

    let v5 = C::use_avx(ctx);

6604

    if v5 == true {

6605

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6606

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmaxsd, arg0, v7);

6607

        // Rule at src/isa/x64/inst.isle line 3516.

6608

        return v8;

6609

6610

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6611

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmaxsd, arg0, v3);

6612

    // Rule at src/isa/x64/inst.isle line 3515.

6613

    return v4;

6614

6615

6616

// Generated as internal constructor for term x64_pmins.

6617

pub fn constructor_x64_pmins<C: Context>(ctx: &mut C, arg0: Type, arg1: Xmm, arg2: &XmmMem) -> Xmm {

6618

    match arg0 {

6619

        I8X16 => {

6620

            let v3 = constructor_x64_pminsb(ctx, arg1, arg2);

6621

            // Rule at src/isa/x64/inst.isle line 3522.

6622

            return v3;

6623

6624

        I16X8 => {

6625

            let v4 = constructor_x64_pminsw(ctx, arg1, arg2);

6626

            // Rule at src/isa/x64/inst.isle line 3523.

6627

            return v4;

6628

6629

        I32X4 => {

6630

            let v5 = constructor_x64_pminsd(ctx, arg1, arg2);

6631

            // Rule at src/isa/x64/inst.isle line 3524.

6632

            return v5;

6633

6634

        _ => {}

6635

6636

    unreachable!(

6637

        "no rule matched for term {} at {}; should it be partial?",

6638

        "x64_pmins", "src/isa/x64/inst.isle line 3521"

6639

6640

6641

6642

// Generated as internal constructor for term x64_pminsb.

6643

pub fn constructor_x64_pminsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6644

    let v5 = C::use_avx(ctx);

6645

    if v5 == true {

6646

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6647

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpminsb, arg0, v7);

6648

        // Rule at src/isa/x64/inst.isle line 3528.

6649

        return v8;

6650

6651

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6652

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pminsb, arg0, v3);

6653

    // Rule at src/isa/x64/inst.isle line 3527.

6654

    return v4;

6655

6656

6657

// Generated as internal constructor for term x64_pminsw.

6658

pub fn constructor_x64_pminsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6659

    let v5 = C::use_avx(ctx);

6660

    if v5 == true {

6661

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6662

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpminsw, arg0, v7);

6663

        // Rule at src/isa/x64/inst.isle line 3533.

6664

        return v8;

6665

6666

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6667

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pminsw, arg0, v3);

6668

    // Rule at src/isa/x64/inst.isle line 3532.

6669

    return v4;

6670

6671

6672

// Generated as internal constructor for term x64_pminsd.

6673

pub fn constructor_x64_pminsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6674

    let v5 = C::use_avx(ctx);

6675

    if v5 == true {

6676

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6677

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpminsd, arg0, v7);

6678

        // Rule at src/isa/x64/inst.isle line 3538.

6679

        return v8;

6680

6681

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6682

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pminsd, arg0, v3);

6683

    // Rule at src/isa/x64/inst.isle line 3537.

6684

    return v4;

6685

6686

6687

// Generated as internal constructor for term x64_pmaxu.

6688

pub fn constructor_x64_pmaxu<C: Context>(ctx: &mut C, arg0: Type, arg1: Xmm, arg2: &XmmMem) -> Xmm {

6689

    match arg0 {

6690

        I8X16 => {

6691

            let v3 = constructor_x64_pmaxub(ctx, arg1, arg2);

6692

            // Rule at src/isa/x64/inst.isle line 3544.

6693

            return v3;

6694

6695

        I16X8 => {

6696

            let v4 = constructor_x64_pmaxuw(ctx, arg1, arg2);

6697

            // Rule at src/isa/x64/inst.isle line 3545.

6698

            return v4;

6699

6700

        I32X4 => {

6701

            let v5 = constructor_x64_pmaxud(ctx, arg1, arg2);

6702

            // Rule at src/isa/x64/inst.isle line 3546.

6703

            return v5;

6704

6705

        _ => {}

6706

6707

    unreachable!(

6708

        "no rule matched for term {} at {}; should it be partial?",

6709

        "x64_pmaxu", "src/isa/x64/inst.isle line 3543"

6710

6711

6712

6713

// Generated as internal constructor for term x64_pmaxub.

6714

pub fn constructor_x64_pmaxub<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6715

    let v5 = C::use_avx(ctx);

6716

    if v5 == true {

6717

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6718

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmaxub, arg0, v7);

6719

        // Rule at src/isa/x64/inst.isle line 3550.

6720

        return v8;

6721

6722

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6723

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmaxub, arg0, v3);

6724

    // Rule at src/isa/x64/inst.isle line 3549.

6725

    return v4;

6726

6727

6728

// Generated as internal constructor for term x64_pmaxuw.

6729

pub fn constructor_x64_pmaxuw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6730

    let v5 = C::use_avx(ctx);

6731

    if v5 == true {

6732

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6733

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmaxuw, arg0, v7);

6734

        // Rule at src/isa/x64/inst.isle line 3555.

6735

        return v8;

6736

6737

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6738

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmaxuw, arg0, v3);

6739

    // Rule at src/isa/x64/inst.isle line 3554.

6740

    return v4;

6741

6742

6743

// Generated as internal constructor for term x64_pmaxud.

6744

pub fn constructor_x64_pmaxud<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6745

    let v5 = C::use_avx(ctx);

6746

    if v5 == true {

6747

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6748

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmaxud, arg0, v7);

6749

        // Rule at src/isa/x64/inst.isle line 3560.

6750

        return v8;

6751

6752

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6753

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmaxud, arg0, v3);

6754

    // Rule at src/isa/x64/inst.isle line 3559.

6755

    return v4;

6756

6757

6758

// Generated as internal constructor for term x64_pminu.

6759

pub fn constructor_x64_pminu<C: Context>(ctx: &mut C, arg0: Type, arg1: Xmm, arg2: &XmmMem) -> Xmm {

6760

    match arg0 {

6761

        I8X16 => {

6762

            let v3 = constructor_x64_pminub(ctx, arg1, arg2);

6763

            // Rule at src/isa/x64/inst.isle line 3566.

6764

            return v3;

6765

6766

        I16X8 => {

6767

            let v4 = constructor_x64_pminuw(ctx, arg1, arg2);

6768

            // Rule at src/isa/x64/inst.isle line 3567.

6769

            return v4;

6770

6771

        I32X4 => {

6772

            let v5 = constructor_x64_pminud(ctx, arg1, arg2);

6773

            // Rule at src/isa/x64/inst.isle line 3568.

6774

            return v5;

6775

6776

        _ => {}

6777

6778

    unreachable!(

6779

        "no rule matched for term {} at {}; should it be partial?",

6780

        "x64_pminu", "src/isa/x64/inst.isle line 3565"

6781

6782

6783

6784

// Generated as internal constructor for term x64_pminub.

6785

pub fn constructor_x64_pminub<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6786

    let v5 = C::use_avx(ctx);

6787

    if v5 == true {

6788

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6789

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpminub, arg0, v7);

6790

        // Rule at src/isa/x64/inst.isle line 3572.

6791

        return v8;

6792

6793

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6794

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pminub, arg0, v3);

6795

    // Rule at src/isa/x64/inst.isle line 3571.

6796

    return v4;

6797

6798

6799

// Generated as internal constructor for term x64_pminuw.

6800

pub fn constructor_x64_pminuw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6801

    let v5 = C::use_avx(ctx);

6802

    if v5 == true {

6803

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6804

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpminuw, arg0, v7);

6805

        // Rule at src/isa/x64/inst.isle line 3577.

6806

        return v8;

6807

6808

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6809

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pminuw, arg0, v3);

6810

    // Rule at src/isa/x64/inst.isle line 3576.

6811

    return v4;

6812

6813

6814

// Generated as internal constructor for term x64_pminud.

6815

pub fn constructor_x64_pminud<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6816

    let v5 = C::use_avx(ctx);

6817

    if v5 == true {

6818

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6819

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpminud, arg0, v7);

6820

        // Rule at src/isa/x64/inst.isle line 3582.

6821

        return v8;

6822

6823

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6824

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pminud, arg0, v3);

6825

    // Rule at src/isa/x64/inst.isle line 3581.

6826

    return v4;

6827

6828

6829

// Generated as internal constructor for term x64_punpcklbw.

6830

pub fn constructor_x64_punpcklbw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6831

    let v5 = C::use_avx(ctx);

6832

    if v5 == true {

6833

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6834

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpunpcklbw, arg0, v7);

6835

        // Rule at src/isa/x64/inst.isle line 3590.

6836

        return v8;

6837

6838

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6839

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Punpcklbw, arg0, v3);

6840

    // Rule at src/isa/x64/inst.isle line 3588.

6841

    return v4;

6842

6843

6844

// Generated as internal constructor for term x64_punpckhbw.

6845

pub fn constructor_x64_punpckhbw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6846

    let v5 = C::use_avx(ctx);

6847

    if v5 == true {

6848

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6849

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpunpckhbw, arg0, v7);

6850

        // Rule at src/isa/x64/inst.isle line 3598.

6851

        return v8;

6852

6853

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6854

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Punpckhbw, arg0, v3);

6855

    // Rule at src/isa/x64/inst.isle line 3596.

6856

    return v4;

6857

6858

6859

// Generated as internal constructor for term x64_packsswb.

6860

pub fn constructor_x64_packsswb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6861

    let v5 = C::use_avx(ctx);

6862

    if v5 == true {

6863

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6864

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpacksswb, arg0, v7);

6865

        // Rule at src/isa/x64/inst.isle line 3606.

6866

        return v8;

6867

6868

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6869

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Packsswb, arg0, v3);

6870

    // Rule at src/isa/x64/inst.isle line 3604.

6871

    return v4;

6872

6873

6874

// Generated as internal constructor for term x64_packssdw.

6875

pub fn constructor_x64_packssdw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6876

    let v5 = C::use_avx(ctx);

6877

    if v5 == true {

6878

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6879

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpackssdw, arg0, v7);

6880

        // Rule at src/isa/x64/inst.isle line 3614.

6881

        return v8;

6882

6883

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6884

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Packssdw, arg0, v3);

6885

    // Rule at src/isa/x64/inst.isle line 3612.

6886

    return v4;

6887

6888

6889

// Generated as internal constructor for term x64_packuswb.

6890

pub fn constructor_x64_packuswb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6891

    let v5 = C::use_avx(ctx);

6892

    if v5 == true {

6893

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6894

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpackuswb, arg0, v7);

6895

        // Rule at src/isa/x64/inst.isle line 3622.

6896

        return v8;

6897

6898

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6899

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Packuswb, arg0, v3);

6900

    // Rule at src/isa/x64/inst.isle line 3620.

6901

    return v4;

6902

6903

6904

// Generated as internal constructor for term x64_packusdw.

6905

pub fn constructor_x64_packusdw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

6906

    let v5 = C::use_avx(ctx);

6907

    if v5 == true {

6908

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

6909

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpackusdw, arg0, v7);

6910

        // Rule at src/isa/x64/inst.isle line 3630.

6911

        return v8;

6912

6913

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

6914

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Packusdw, arg0, v3);

6915

    // Rule at src/isa/x64/inst.isle line 3628.

6916

    return v4;

6917

6918

6919

// Generated as internal constructor for term x64_palignr.

6920

pub fn constructor_x64_palignr<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> Xmm {

6921

    let v8 = C::use_avx(ctx);

6922

    if v8 == true {

6923

        let v10 = constructor_xmm_rmr_imm_vex(ctx, &AvxOpcode::Vpalignr, arg0, arg1, arg2);

6924

        // Rule at src/isa/x64/inst.isle line 3642.

6925

        return v10;

6926

6927

    let v4 = C::xmm_to_reg(ctx, arg0);

6928

    let v5 = &C::xmm_mem_to_reg_mem(ctx, arg1);

6929

    let v7 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Palignr, v4, v5, arg2, &OperandSize::Size32);

6930

    // Rule at src/isa/x64/inst.isle line 3636.

6931

    return v7;

6932

6933

6934

// Generated as internal constructor for term x64_cmpp.

6935

pub fn constructor_x64_cmpp<C: Context>(

6936

    ctx: &mut C,

6937

    arg0: Type,

6938

    arg1: Xmm,

6939

    arg2: &XmmMem,

6940

    arg3: &FcmpImm,

6941

) -> Xmm {

6942

    match arg0 {

6943

        F32X4 => {

6944

            let v4 = constructor_x64_cmpps(ctx, arg1, arg2, arg3);

6945

            // Rule at src/isa/x64/inst.isle line 3648.

6946

            return v4;

6947

6948

        F64X2 => {

6949

            let v5 = constructor_x64_cmppd(ctx, arg1, arg2, arg3);

6950

            // Rule at src/isa/x64/inst.isle line 3649.

6951

            return v5;

6952

6953

        _ => {}

6954

6955

    unreachable!(

6956

        "no rule matched for term {} at {}; should it be partial?",

6957

        "x64_cmpp", "src/isa/x64/inst.isle line 3647"

6958

6959

6960

6961

// Generated as internal constructor for term x64_cmpps.

6962

pub fn constructor_x64_cmpps<C: Context>(

6963

    ctx: &mut C,

6964

    arg0: Xmm,

6965

    arg1: &XmmMem,

6966

    arg2: &FcmpImm,

6967

) -> Xmm {

6968

    let v9 = C::use_avx(ctx);

6969

    if v9 == true {

6970

        let v11 = C::encode_fcmp_imm(ctx, arg2);

6971

        let v12 = constructor_xmm_rmr_imm_vex(ctx, &AvxOpcode::Vcmpps, arg0, arg1, v11);

6972

        // Rule at src/isa/x64/inst.isle line 3658.

6973

        return v12;

6974

6975

    let v4 = C::xmm_to_reg(ctx, arg0);

6976

    let v5 = &C::xmm_mem_to_reg_mem(ctx, arg1);

6977

    let v6 = C::encode_fcmp_imm(ctx, arg2);

6978

    let v8 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Cmpps, v4, v5, v6, &OperandSize::Size32);

6979

    // Rule at src/isa/x64/inst.isle line 3652.

6980

    return v8;

6981

6982

6983

// Generated as internal constructor for term x64_cmppd.

6984

pub fn constructor_x64_cmppd<C: Context>(

6985

    ctx: &mut C,

6986

    arg0: Xmm,

6987

    arg1: &XmmMem,

6988

    arg2: &FcmpImm,

6989

) -> Xmm {

6990

    let v9 = C::use_avx(ctx);

6991

    if v9 == true {

6992

        let v11 = C::encode_fcmp_imm(ctx, arg2);

6993

        let v12 = constructor_xmm_rmr_imm_vex(ctx, &AvxOpcode::Vcmppd, arg0, arg1, v11);

6994

        // Rule at src/isa/x64/inst.isle line 3675.

6995

        return v12;

6996

6997

    let v4 = C::xmm_to_reg(ctx, arg0);

6998

    let v5 = &C::xmm_mem_to_reg_mem(ctx, arg1);

6999

    let v6 = C::encode_fcmp_imm(ctx, arg2);

7000

    let v8 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Cmppd, v4, v5, v6, &OperandSize::Size32);

7001

    // Rule at src/isa/x64/inst.isle line 3669.

7002

    return v8;

7003

7004

7005

// Generated as internal constructor for term x64_pinsrb.

7006

pub fn constructor_x64_pinsrb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &GprMem, arg2: u8) -> Xmm {

7007

    let v8 = C::use_avx(ctx);

7008

    if v8 == true {

7009

        let v10 = constructor_xmm_vex_pinsr(ctx, &AvxOpcode::Vpinsrb, arg0, arg1, arg2);

7010

        // Rule at src/isa/x64/inst.isle line 3690.

7011

        return v10;

7012

7013

    let v4 = C::xmm_to_reg(ctx, arg0);

7014

    let v5 = &C::gpr_mem_to_reg_mem(ctx, arg1);

7015

    let v7 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Pinsrb, v4, v5, arg2, &OperandSize::Size32);

7016

    // Rule at src/isa/x64/inst.isle line 3684.

7017

    return v7;

7018

7019

7020

// Generated as internal constructor for term x64_pinsrw.

7021

pub fn constructor_x64_pinsrw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &GprMem, arg2: u8) -> Xmm {

7022

    let v8 = C::use_avx(ctx);

7023

    if v8 == true {

7024

        let v10 = constructor_xmm_vex_pinsr(ctx, &AvxOpcode::Vpinsrw, arg0, arg1, arg2);

7025

        // Rule at src/isa/x64/inst.isle line 3702.

7026

        return v10;

7027

7028

    let v4 = C::xmm_to_reg(ctx, arg0);

7029

    let v5 = &C::gpr_mem_to_reg_mem(ctx, arg1);

7030

    let v7 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Pinsrw, v4, v5, arg2, &OperandSize::Size32);

7031

    // Rule at src/isa/x64/inst.isle line 3696.

7032

    return v7;

7033

7034

7035

// Generated as internal constructor for term x64_pinsrd.

7036

pub fn constructor_x64_pinsrd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &GprMem, arg2: u8) -> Xmm {

7037

    let v8 = C::use_avx(ctx);

7038

    if v8 == true {

7039

        let v10 = constructor_xmm_vex_pinsr(ctx, &AvxOpcode::Vpinsrd, arg0, arg1, arg2);

7040

        // Rule at src/isa/x64/inst.isle line 3714.

7041

        return v10;

7042

7043

    let v4 = C::xmm_to_reg(ctx, arg0);

7044

    let v5 = &C::gpr_mem_to_reg_mem(ctx, arg1);

7045

    let v7 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Pinsrd, v4, v5, arg2, &OperandSize::Size32);

7046

    // Rule at src/isa/x64/inst.isle line 3708.

7047

    return v7;

7048

7049

7050

// Generated as internal constructor for term x64_pinsrq.

7051

pub fn constructor_x64_pinsrq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &GprMem, arg2: u8) -> Xmm {

7052

    let v8 = C::use_avx(ctx);

7053

    if v8 == true {

7054

        let v10 = constructor_xmm_vex_pinsr(ctx, &AvxOpcode::Vpinsrq, arg0, arg1, arg2);

7055

        // Rule at src/isa/x64/inst.isle line 3726.

7056

        return v10;

7057

7058

    let v4 = C::xmm_to_reg(ctx, arg0);

7059

    let v5 = &C::gpr_mem_to_reg_mem(ctx, arg1);

7060

    let v7 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Pinsrd, v4, v5, arg2, &OperandSize::Size64);

7061

    // Rule at src/isa/x64/inst.isle line 3720.

7062

    return v7;

7063

7064

7065

// Generated as internal constructor for term x64_roundss.

7066

pub fn constructor_x64_roundss<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: &RoundImm) -> Xmm {

7067

    let v6 = C::use_avx(ctx);

7068

    if v6 == true {

7069

        let v8 = C::encode_round_imm(ctx, arg1);

7070

        let v9 = constructor_xmm_unary_rm_r_imm_vex(ctx, &AvxOpcode::Vroundss, arg0, v8);

7071

        // Rule at src/isa/x64/inst.isle line 3734.

7072

        return v9;

7073

7074

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

7075

    let v4 = C::encode_round_imm(ctx, arg1);

7076

    let v5 = constructor_xmm_unary_rm_r_imm(ctx, &SseOpcode::Roundss, v3, v4);

7077

    // Rule at src/isa/x64/inst.isle line 3732.

7078

    return v5;

7079

7080

7081

// Generated as internal constructor for term x64_roundsd.

7082

pub fn constructor_x64_roundsd<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: &RoundImm) -> Xmm {

7083

    let v6 = C::use_avx(ctx);

7084

    if v6 == true {

7085

        let v8 = C::encode_round_imm(ctx, arg1);

7086

        let v9 = constructor_xmm_unary_rm_r_imm_vex(ctx, &AvxOpcode::Vroundsd, arg0, v8);

7087

        // Rule at src/isa/x64/inst.isle line 3742.

7088

        return v9;

7089

7090

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

7091

    let v4 = C::encode_round_imm(ctx, arg1);

7092

    let v5 = constructor_xmm_unary_rm_r_imm(ctx, &SseOpcode::Roundsd, v3, v4);

7093

    // Rule at src/isa/x64/inst.isle line 3740.

7094

    return v5;

7095

7096

7097

// Generated as internal constructor for term x64_roundps.

7098

pub fn constructor_x64_roundps<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: &RoundImm) -> Xmm {

7099

    let v6 = C::use_avx(ctx);

7100

    if v6 == true {

7101

        let v8 = C::encode_round_imm(ctx, arg1);

7102

        let v9 = constructor_xmm_unary_rm_r_imm_vex(ctx, &AvxOpcode::Vroundps, arg0, v8);

7103

        // Rule at src/isa/x64/inst.isle line 3750.

7104

        return v9;

7105

7106

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

7107

    let v4 = C::encode_round_imm(ctx, arg1);

7108

    let v5 = constructor_xmm_unary_rm_r_imm(ctx, &SseOpcode::Roundps, v3, v4);

7109

    // Rule at src/isa/x64/inst.isle line 3748.

7110

    return v5;

7111

7112

7113

// Generated as internal constructor for term x64_roundpd.

7114

pub fn constructor_x64_roundpd<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: &RoundImm) -> Xmm {

7115

    let v6 = C::use_avx(ctx);

7116

    if v6 == true {

7117

        let v8 = C::encode_round_imm(ctx, arg1);

7118

        let v9 = constructor_xmm_unary_rm_r_imm_vex(ctx, &AvxOpcode::Vroundpd, arg0, v8);

7119

        // Rule at src/isa/x64/inst.isle line 3758.

7120

        return v9;

7121

7122

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

7123

    let v4 = C::encode_round_imm(ctx, arg1);

7124

    let v5 = constructor_xmm_unary_rm_r_imm(ctx, &SseOpcode::Roundpd, v3, v4);

7125

    // Rule at src/isa/x64/inst.isle line 3756.

7126

    return v5;

7127

7128

7129

// Generated as internal constructor for term x64_pmaddwd.

7130

pub fn constructor_x64_pmaddwd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

7131

    let v5 = C::use_avx(ctx);

7132

    if v5 == true {

7133

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

7134

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmaddwd, arg0, v7);

7135

        // Rule at src/isa/x64/inst.isle line 3766.

7136

        return v8;

7137

7138

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

7139

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmaddwd, arg0, v3);

7140

    // Rule at src/isa/x64/inst.isle line 3764.

7141

    return v4;

7142

7143

7144

// Generated as internal constructor for term x64_pmaddubsw.

7145

pub fn constructor_x64_pmaddubsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

7146

    let v5 = C::use_avx(ctx);

7147

    if v5 == true {

7148

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

7149

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmaddubsw, arg0, v7);

7150

        // Rule at src/isa/x64/inst.isle line 3773.

7151

        return v8;

7152

7153

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

7154

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmaddubsw, arg0, v3);

7155

    // Rule at src/isa/x64/inst.isle line 3771.

7156

    return v4;

7157

7158

7159

// Generated as internal constructor for term x64_insertps.

7160

pub fn constructor_x64_insertps<C: Context>(

7161

    ctx: &mut C,

7162

    arg0: Xmm,

7163

    arg1: &XmmMem,

7164

    arg2: u8,

7165

) -> Xmm {

7166

    let v8 = C::use_avx(ctx);

7167

    if v8 == true {

7168

        let v10 = constructor_xmm_rmr_imm_vex(ctx, &AvxOpcode::Vinsertps, arg0, arg1, arg2);

7169

        // Rule at src/isa/x64/inst.isle line 3785.

7170

        return v10;

7171

7172

    let v4 = C::xmm_to_reg(ctx, arg0);

7173

    let v5 = &C::xmm_mem_to_reg_mem(ctx, arg1);

7174

    let v7 = constructor_xmm_rm_r_imm(

7175

        ctx,

7176

        &SseOpcode::Insertps,

7177

v4,

7178

v5,

7179

        arg2,

7180

        &OperandSize::Size32,

7181

);

7182

    // Rule at src/isa/x64/inst.isle line 3779.

7183

    return v7;

7184

7185

7186

// Generated as internal constructor for term x64_pshufd.

7187

pub fn constructor_x64_pshufd<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: u8) -> Xmm {

7188

    let v5 = C::use_avx(ctx);

7189

    if v5 == true {

7190

        let v7 = constructor_xmm_unary_rm_r_imm_vex(ctx, &AvxOpcode::Vpshufd, arg0, arg1);

7191

        // Rule at src/isa/x64/inst.isle line 3793.

7192

        return v7;

7193

7194

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

7195

    let v4 = constructor_xmm_unary_rm_r_imm(ctx, &SseOpcode::Pshufd, v3, arg1);

7196

    // Rule at src/isa/x64/inst.isle line 3791.

7197

    return v4;

7198

7199

7200

// Generated as internal constructor for term x64_pshufb.

7201

pub fn constructor_x64_pshufb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

7202

    let v5 = C::use_avx(ctx);

7203

    if v5 == true {

7204

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

7205

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpshufb, arg0, v7);

7206

        // Rule at src/isa/x64/inst.isle line 3801.

7207

        return v8;

7208

7209

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

7210

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pshufb, arg0, v3);

7211

    // Rule at src/isa/x64/inst.isle line 3799.

7212

    return v4;

7213

7214

7215

// Generated as internal constructor for term x64_pshuflw.

7216

pub fn constructor_x64_pshuflw<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: u8) -> Xmm {

7217

    let v5 = C::use_avx(ctx);

7218

    if v5 == true {

7219

        let v7 = constructor_xmm_unary_rm_r_imm_vex(ctx, &AvxOpcode::Vpshuflw, arg0, arg1);

7220

        // Rule at src/isa/x64/inst.isle line 3809.

7221

        return v7;

7222

7223

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

7224

    let v4 = constructor_xmm_unary_rm_r_imm(ctx, &SseOpcode::Pshuflw, v3, arg1);

7225

    // Rule at src/isa/x64/inst.isle line 3807.

7226

    return v4;

7227

7228

7229

// Generated as internal constructor for term x64_pshufhw.

7230

pub fn constructor_x64_pshufhw<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: u8) -> Xmm {

7231

    let v5 = C::use_avx(ctx);

7232

    if v5 == true {

7233

        let v7 = constructor_xmm_unary_rm_r_imm_vex(ctx, &AvxOpcode::Vpshufhw, arg0, arg1);

7234

        // Rule at src/isa/x64/inst.isle line 3817.

7235

        return v7;

7236

7237

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

7238

    let v4 = constructor_xmm_unary_rm_r_imm(ctx, &SseOpcode::Pshufhw, v3, arg1);

7239

    // Rule at src/isa/x64/inst.isle line 3815.

7240

    return v4;

7241

7242

7243

// Generated as internal constructor for term x64_shufps.

7244

pub fn constructor_x64_shufps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> Xmm {

7245

    let v8 = C::use_avx(ctx);

7246

    if v8 == true {

7247

        let v10 = constructor_xmm_rmr_imm_vex(ctx, &AvxOpcode::Vshufps, arg0, arg1, arg2);

7248

        // Rule at src/isa/x64/inst.isle line 3829.

7249

        return v10;

7250

7251

    let v4 = C::xmm_to_reg(ctx, arg0);

7252

    let v5 = &C::xmm_mem_to_reg_mem(ctx, arg1);

7253

    let v7 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Shufps, v4, v5, arg2, &OperandSize::Size32);

7254

    // Rule at src/isa/x64/inst.isle line 3823.

7255

    return v7;

7256

7257

7258

// Generated as internal constructor for term x64_pabsb.

7259

pub fn constructor_x64_pabsb<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

7260

    let v4 = C::use_avx(ctx);

7261

    if v4 == true {

7262

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpabsb, arg0);

7263

        // Rule at src/isa/x64/inst.isle line 3837.

7264

        return v6;

7265

7266

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

7267

    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Pabsb, v2);

7268

    // Rule at src/isa/x64/inst.isle line 3835.

7269

    return v3;

7270

7271

7272

// Generated as internal constructor for term x64_pabsw.

7273

pub fn constructor_x64_pabsw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

7274

    let v4 = C::use_avx(ctx);

7275

    if v4 == true {

7276

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpabsw, arg0);

7277

        // Rule at src/isa/x64/inst.isle line 3845.

7278

        return v6;

7279

7280

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

7281

    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Pabsw, v2);

7282

    // Rule at src/isa/x64/inst.isle line 3843.

7283

    return v3;

7284

7285

7286

// Generated as internal constructor for term x64_pabsd.

7287

pub fn constructor_x64_pabsd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

7288

    let v4 = C::use_avx(ctx);

7289

    if v4 == true {

7290

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpabsd, arg0);

7291

        // Rule at src/isa/x64/inst.isle line 3853.

7292

        return v6;

7293

7294

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

7295

    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Pabsd, v2);

7296

    // Rule at src/isa/x64/inst.isle line 3851.

7297

    return v3;

7298

7299

7300

// Generated as internal constructor for term x64_vcvtudq2ps.

7301

pub fn constructor_x64_vcvtudq2ps<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

7302

    let v2 = constructor_xmm_unary_rm_r_evex(ctx, &Avx512Opcode::Vcvtudq2ps, arg0);

7303

    // Rule at src/isa/x64/inst.isle line 3859.

7304

    return v2;

7305

7306

7307

// Generated as internal constructor for term x64_vpabsq.

7308

pub fn constructor_x64_vpabsq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

7309

    let v2 = constructor_xmm_unary_rm_r_evex(ctx, &Avx512Opcode::Vpabsq, arg0);

7310

    // Rule at src/isa/x64/inst.isle line 3864.

7311

    return v2;

7312

7313

7314

// Generated as internal constructor for term x64_vpopcntb.

7315

pub fn constructor_x64_vpopcntb<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

7316

    let v2 = constructor_xmm_unary_rm_r_evex(ctx, &Avx512Opcode::Vpopcntb, arg0);

7317

    // Rule at src/isa/x64/inst.isle line 3869.

7318

    return v2;

7319

7320

7321

// Generated as internal constructor for term x64_vpmullq.

7322

pub fn constructor_x64_vpmullq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

7323

    let v3 = constructor_xmm_rm_r_evex(ctx, &Avx512Opcode::Vpmullq, arg0, arg1);

7324

    // Rule at src/isa/x64/inst.isle line 3876.

7325

    return v3;

7326

7327

7328

// Generated as internal constructor for term x64_vpermi2b.

7329

pub fn constructor_x64_vpermi2b<C: Context>(

7330

    ctx: &mut C,

7331

    arg0: Xmm,

7332

    arg1: Xmm,

7333

    arg2: &XmmMem,

7334

) -> Xmm {

7335

    let v3 = C::temp_writable_xmm(ctx);

7336

    let v5 = MInst::XmmRmREvex3 {

7337

        op: Avx512Opcode::Vpermi2b,

7338

        src1: arg0,

7339

        src2: arg1,

7340

        src3: arg2.clone(),

7341

        dst: v3,

7342

};

7343

    let v6 = C::emit(ctx, &v5);

7344

    let v7 = C::writable_xmm_to_xmm(ctx, v3);

7345

    // Rule at src/isa/x64/inst.isle line 3885.

7346

    return v7;

7347

7348

7349

// Generated as internal constructor for term mulhi_u.

7350

pub fn constructor_mulhi_u<C: Context>(

7351

    ctx: &mut C,

7352

    arg0: Type,

7353

    arg1: Gpr,

7354

    arg2: &GprMem,

7355

) -> ValueRegs {

7356

    let v4 = constructor_mul_hi(ctx, arg0, false, arg1, arg2);

7357

    // Rule at src/isa/x64/inst.isle line 3897.

7358

    return v4;

7359

7360

7361

// Generated as internal constructor for term x64_psllw.

7362

pub fn constructor_x64_psllw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Xmm {

7363

    let v5 = C::use_avx(ctx);

7364

    if v5 == true {

7365

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsllw, arg0, arg1);

7366

        // Rule at src/isa/x64/inst.isle line 3904.

7367

        return v7;

7368

7369

    let v3 = &C::xmm_mem_imm_to_xmm_mem_aligned_imm(ctx, arg1);

7370

    let v4 = constructor_xmm_rmi_xmm(ctx, &SseOpcode::Psllw, arg0, v3);

7371

    // Rule at src/isa/x64/inst.isle line 3902.

7372

    return v4;

7373

7374

7375

// Generated as internal constructor for term x64_pslld.

7376

pub fn constructor_x64_pslld<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Xmm {

7377

    let v5 = C::use_avx(ctx);

7378

    if v5 == true {

7379

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpslld, arg0, arg1);

7380

        // Rule at src/isa/x64/inst.isle line 3912.

7381

        return v7;

7382

7383

    let v3 = &C::xmm_mem_imm_to_xmm_mem_aligned_imm(ctx, arg1);

7384

    let v4 = constructor_xmm_rmi_xmm(ctx, &SseOpcode::Pslld, arg0, v3);

7385

    // Rule at src/isa/x64/inst.isle line 3910.

7386

    return v4;

7387

7388

7389

// Generated as internal constructor for term x64_psllq.

7390

pub fn constructor_x64_psllq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Xmm {

7391

    let v5 = C::use_avx(ctx);

7392

    if v5 == true {

7393

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsllq, arg0, arg1);

7394

        // Rule at src/isa/x64/inst.isle line 3920.

7395

        return v7;

7396

7397

    let v3 = &C::xmm_mem_imm_to_xmm_mem_aligned_imm(ctx, arg1);

7398

    let v4 = constructor_xmm_rmi_xmm(ctx, &SseOpcode::Psllq, arg0, v3);

7399

    // Rule at src/isa/x64/inst.isle line 3918.

7400

    return v4;

7401

7402

7403

// Generated as internal constructor for term x64_psrlw.

7404

pub fn constructor_x64_psrlw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Xmm {

7405

    let v5 = C::use_avx(ctx);

7406

    if v5 == true {

7407

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsrlw, arg0, arg1);

7408

        // Rule at src/isa/x64/inst.isle line 3928.

7409

        return v7;

7410

7411

    let v3 = &C::xmm_mem_imm_to_xmm_mem_aligned_imm(ctx, arg1);

7412

    let v4 = constructor_xmm_rmi_xmm(ctx, &SseOpcode::Psrlw, arg0, v3);

7413

    // Rule at src/isa/x64/inst.isle line 3926.

7414

    return v4;

7415

7416

7417

// Generated as internal constructor for term x64_psrld.

7418

pub fn constructor_x64_psrld<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Xmm {

7419

    let v5 = C::use_avx(ctx);

7420

    if v5 == true {

7421

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsrld, arg0, arg1);

7422

        // Rule at src/isa/x64/inst.isle line 3936.

7423

        return v7;

7424

7425

    let v3 = &C::xmm_mem_imm_to_xmm_mem_aligned_imm(ctx, arg1);

7426

    let v4 = constructor_xmm_rmi_xmm(ctx, &SseOpcode::Psrld, arg0, v3);

7427

    // Rule at src/isa/x64/inst.isle line 3934.

7428

    return v4;

7429

7430

7431

// Generated as internal constructor for term x64_psrlq.

7432

pub fn constructor_x64_psrlq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Xmm {

7433

    let v5 = C::use_avx(ctx);

7434

    if v5 == true {

7435

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsrlq, arg0, arg1);

7436

        // Rule at src/isa/x64/inst.isle line 3944.

7437

        return v7;

7438

7439

    let v3 = &C::xmm_mem_imm_to_xmm_mem_aligned_imm(ctx, arg1);

7440

    let v4 = constructor_xmm_rmi_xmm(ctx, &SseOpcode::Psrlq, arg0, v3);

7441

    // Rule at src/isa/x64/inst.isle line 3942.

7442

    return v4;

7443

7444

7445

// Generated as internal constructor for term x64_psraw.

7446

pub fn constructor_x64_psraw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Xmm {

7447

    let v5 = C::use_avx(ctx);

7448

    if v5 == true {

7449

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsraw, arg0, arg1);

7450

        // Rule at src/isa/x64/inst.isle line 3952.

7451

        return v7;

7452

7453

    let v3 = &C::xmm_mem_imm_to_xmm_mem_aligned_imm(ctx, arg1);

7454

    let v4 = constructor_xmm_rmi_xmm(ctx, &SseOpcode::Psraw, arg0, v3);

7455

    // Rule at src/isa/x64/inst.isle line 3950.

7456

    return v4;

7457

7458

7459

// Generated as internal constructor for term x64_psrad.

7460

pub fn constructor_x64_psrad<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Xmm {

7461

    let v5 = C::use_avx(ctx);

7462

    if v5 == true {

7463

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsrad, arg0, arg1);

7464

        // Rule at src/isa/x64/inst.isle line 3960.

7465

        return v7;

7466

7467

    let v3 = &C::xmm_mem_imm_to_xmm_mem_aligned_imm(ctx, arg1);

7468

    let v4 = constructor_xmm_rmi_xmm(ctx, &SseOpcode::Psrad, arg0, v3);

7469

    // Rule at src/isa/x64/inst.isle line 3958.

7470

    return v4;

7471

7472

7473

// Generated as internal constructor for term x64_vpsraq.

7474

pub fn constructor_x64_vpsraq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

7475

    let v3 = constructor_xmm_rm_r_evex(ctx, &Avx512Opcode::Vpsraq, arg0, arg1);

7476

    // Rule at src/isa/x64/inst.isle line 3966.

7477

    return v3;

7478

7479

7480

// Generated as internal constructor for term x64_vpsraq_imm.

7481

pub fn constructor_x64_vpsraq_imm<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: u8) -> Xmm {

7482

    let v3 = constructor_xmm_unary_rm_r_imm_evex(ctx, &Avx512Opcode::VpsraqImm, arg0, arg1);

7483

    // Rule at src/isa/x64/inst.isle line 3971.

7484

    return v3;

7485

7486

7487

// Generated as internal constructor for term x64_pextrb.

7488

pub fn constructor_x64_pextrb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: u8) -> Gpr {

7489

    let v4 = C::use_avx(ctx);

7490

    if v4 == true {

7491

        let v6 = constructor_xmm_to_gpr_imm_vex(ctx, &AvxOpcode::Vpextrb, arg0, arg1);

7492

        // Rule at src/isa/x64/inst.isle line 3978.

7493

        return v6;

7494

7495

    let v3 = constructor_xmm_to_gpr_imm(ctx, &SseOpcode::Pextrb, arg0, arg1);

7496

    // Rule at src/isa/x64/inst.isle line 3976.

7497

    return v3;

7498

7499

7500

// Generated as internal constructor for term x64_pextrb_store.

7501

pub fn constructor_x64_pextrb_store<C: Context>(

7502

    ctx: &mut C,

7503

    arg0: &SyntheticAmode,

7504

    arg1: Xmm,

7505

    arg2: u8,

7506

) -> SideEffectNoResult {

7507

    let v5 = C::use_avx(ctx);

7508

    if v5 == true {

7509

        let v7 = &constructor_xmm_movrm_imm_vex(ctx, &AvxOpcode::Vpextrb, arg0, arg1, arg2);

7510

        // Rule at src/isa/x64/inst.isle line 3985.

7511

        return v7.clone();

7512

7513

    let v4 = &constructor_xmm_movrm_imm(ctx, &SseOpcode::Pextrb, arg0, arg1, arg2);

7514

    // Rule at src/isa/x64/inst.isle line 3983.

7515

    return v4.clone();

7516

7517

7518

// Generated as internal constructor for term x64_pextrw.

7519

pub fn constructor_x64_pextrw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: u8) -> Gpr {

7520

    let v4 = C::use_avx(ctx);

7521

    if v4 == true {

7522

        let v6 = constructor_xmm_to_gpr_imm_vex(ctx, &AvxOpcode::Vpextrw, arg0, arg1);

7523

        // Rule at src/isa/x64/inst.isle line 3993.

7524

        return v6;

7525

7526

    let v3 = constructor_xmm_to_gpr_imm(ctx, &SseOpcode::Pextrw, arg0, arg1);

7527

    // Rule at src/isa/x64/inst.isle line 3991.

7528

    return v3;

7529

7530

7531

// Generated as internal constructor for term x64_pextrw_store.

7532

pub fn constructor_x64_pextrw_store<C: Context>(

7533

    ctx: &mut C,

7534

    arg0: &SyntheticAmode,

7535

    arg1: Xmm,

7536

    arg2: u8,

7537

) -> SideEffectNoResult {

7538

    let v5 = C::use_avx(ctx);

7539

    if v5 == true {

7540

        let v7 = &constructor_xmm_movrm_imm_vex(ctx, &AvxOpcode::Vpextrw, arg0, arg1, arg2);

7541

        // Rule at src/isa/x64/inst.isle line 4000.

7542

        return v7.clone();

7543

7544

    let v4 = &constructor_xmm_movrm_imm(ctx, &SseOpcode::Pextrw, arg0, arg1, arg2);

7545

    // Rule at src/isa/x64/inst.isle line 3998.

7546

    return v4.clone();

7547

7548

7549

// Generated as internal constructor for term x64_pextrd.

7550

pub fn constructor_x64_pextrd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: u8) -> Gpr {

7551

    let v4 = C::use_avx(ctx);

7552

    if v4 == true {

7553

        let v6 = constructor_xmm_to_gpr_imm_vex(ctx, &AvxOpcode::Vpextrd, arg0, arg1);

7554

        // Rule at src/isa/x64/inst.isle line 4008.

7555

        return v6;

7556

7557

    let v3 = constructor_xmm_to_gpr_imm(ctx, &SseOpcode::Pextrd, arg0, arg1);

7558

    // Rule at src/isa/x64/inst.isle line 4006.

7559

    return v3;

7560

7561

7562

// Generated as internal constructor for term x64_pextrd_store.

7563

pub fn constructor_x64_pextrd_store<C: Context>(

7564

    ctx: &mut C,

7565

    arg0: &SyntheticAmode,

7566

    arg1: Xmm,

7567

    arg2: u8,

7568

) -> SideEffectNoResult {

7569

    let v5 = C::use_avx(ctx);

7570

    if v5 == true {

7571

        let v7 = &constructor_xmm_movrm_imm_vex(ctx, &AvxOpcode::Vpextrd, arg0, arg1, arg2);

7572

        // Rule at src/isa/x64/inst.isle line 4015.

7573

        return v7.clone();

7574

7575

    let v4 = &constructor_xmm_movrm_imm(ctx, &SseOpcode::Pextrd, arg0, arg1, arg2);

7576

    // Rule at src/isa/x64/inst.isle line 4013.

7577

    return v4.clone();

7578

7579

7580

// Generated as internal constructor for term x64_pextrq.

7581

pub fn constructor_x64_pextrq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: u8) -> Gpr {

7582

    let v4 = C::use_avx(ctx);

7583

    if v4 == true {

7584

        let v6 = constructor_xmm_to_gpr_imm_vex(ctx, &AvxOpcode::Vpextrq, arg0, arg1);

7585

        // Rule at src/isa/x64/inst.isle line 4023.

7586

        return v6;

7587

7588

    let v3 = constructor_xmm_to_gpr_imm(ctx, &SseOpcode::Pextrq, arg0, arg1);

7589

    // Rule at src/isa/x64/inst.isle line 4021.

7590

    return v3;

7591

7592

7593

// Generated as internal constructor for term x64_pextrq_store.

7594

pub fn constructor_x64_pextrq_store<C: Context>(

7595

    ctx: &mut C,

7596

    arg0: &SyntheticAmode,

7597

    arg1: Xmm,

7598

    arg2: u8,

7599

) -> SideEffectNoResult {

7600

    let v5 = C::use_avx(ctx);

7601

    if v5 == true {

7602

        let v7 = &constructor_xmm_movrm_imm_vex(ctx, &AvxOpcode::Vpextrq, arg0, arg1, arg2);

7603

        // Rule at src/isa/x64/inst.isle line 4030.

7604

        return v7.clone();

7605

7606

    let v4 = &constructor_xmm_movrm_imm(ctx, &SseOpcode::Pextrq, arg0, arg1, arg2);

7607

    // Rule at src/isa/x64/inst.isle line 4028.

7608

    return v4.clone();

7609

7610

7611

// Generated as internal constructor for term x64_pmovmskb.

7612

pub fn constructor_x64_pmovmskb<C: Context>(ctx: &mut C, arg0: &OperandSize, arg1: Xmm) -> Gpr {

7613

    let v4 = C::use_avx(ctx);

7614

    if v4 == true {

7615

        let v6 = constructor_xmm_to_gpr_vex(ctx, &AvxOpcode::Vpmovmskb, arg1, arg0);

7616

        // Rule at src/isa/x64/inst.isle line 4038.

7617

        return v6;

7618

7619

    let v3 = constructor_xmm_to_gpr(ctx, &SseOpcode::Pmovmskb, arg1, arg0);

7620

    // Rule at src/isa/x64/inst.isle line 4036.

7621

    return v3;

7622

7623

7624

// Generated as internal constructor for term x64_movmskps.

7625

pub fn constructor_x64_movmskps<C: Context>(ctx: &mut C, arg0: &OperandSize, arg1: Xmm) -> Gpr {

7626

    let v4 = C::use_avx(ctx);

7627

    if v4 == true {

7628

        let v6 = constructor_xmm_to_gpr_vex(ctx, &AvxOpcode::Vmovmskps, arg1, arg0);

7629

        // Rule at src/isa/x64/inst.isle line 4046.

7630

        return v6;

7631

7632

    let v3 = constructor_xmm_to_gpr(ctx, &SseOpcode::Movmskps, arg1, arg0);

7633

    // Rule at src/isa/x64/inst.isle line 4044.

7634

    return v3;

7635

7636

7637

// Generated as internal constructor for term x64_movmskpd.

7638

pub fn constructor_x64_movmskpd<C: Context>(ctx: &mut C, arg0: &OperandSize, arg1: Xmm) -> Gpr {

7639

    let v4 = C::use_avx(ctx);

7640

    if v4 == true {

7641

        let v6 = constructor_xmm_to_gpr_vex(ctx, &AvxOpcode::Vmovmskpd, arg1, arg0);

7642

        // Rule at src/isa/x64/inst.isle line 4054.

7643

        return v6;

7644

7645

    let v3 = constructor_xmm_to_gpr(ctx, &SseOpcode::Movmskpd, arg1, arg0);

7646

    // Rule at src/isa/x64/inst.isle line 4052.

7647

    return v3;

7648

7649

7650

// Generated as internal constructor for term x64_not.

7651

pub fn constructor_x64_not<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {

7652

    let v2 = C::temp_writable_gpr(ctx);

7653

    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);

7654

    let v4 = MInst::Not {

7655

        size: v3.clone(),

7656

        src: arg1,

7657

        dst: v2,

7658

};

7659

    let v5 = C::emit(ctx, &v4);

7660

    let v6 = C::writable_gpr_to_gpr(ctx, v2);

7661

    // Rule at src/isa/x64/inst.isle line 4060.

7662

    return v6;

7663

7664

7665

// Generated as internal constructor for term x64_neg.

7666

pub fn constructor_x64_neg<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {

7667

    let v2 = C::temp_writable_gpr(ctx);

7668

    let v3 = &C::raw_operand_size_of_type(ctx, arg0);

7669

    let v4 = MInst::Neg {

7670

        size: v3.clone(),

7671

        src: arg1,

7672

        dst: v2,

7673

};

7674

    let v5 = C::emit(ctx, &v4);

7675

    let v6 = C::writable_gpr_to_gpr(ctx, v2);

7676

    // Rule at src/isa/x64/inst.isle line 4068.

7677

    return v6;

7678

7679

7680

// Generated as internal constructor for term x64_neg_paired.

7681

pub fn constructor_x64_neg_paired<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> ProducesFlags {

7682

    let v2 = C::temp_writable_gpr(ctx);

7683

    let v3 = &C::raw_operand_size_of_type(ctx, arg0);

7684

    let v5 = constructor_writable_gpr_to_r_reg(ctx, v2);

7685

    let v4 = MInst::Neg {

7686

        size: v3.clone(),

7687

        src: arg1,

7688

        dst: v2,

7689

};

7690

    let v6 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer {

7691

        inst: v4,

7692

        result: v5,

7693

};

7694

    // Rule at src/isa/x64/inst.isle line 4076.

7695

    return v6;

7696

7697

7698

// Generated as internal constructor for term x64_lea.

7699

pub fn constructor_x64_lea<C: Context>(ctx: &mut C, arg0: Type, arg1: &SyntheticAmode) -> Gpr {

7700

    let v2 = C::temp_writable_gpr(ctx);

7701

    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);

7702

    let v4 = MInst::LoadEffectiveAddress {

7703

        addr: arg1.clone(),

7704

        dst: v2,

7705

        size: v3.clone(),

7706

};

7707

    let v5 = C::emit(ctx, &v4);

7708

    let v6 = C::writable_gpr_to_gpr(ctx, v2);

7709

    // Rule at src/isa/x64/inst.isle line 4083.

7710

    return v6;

7711

7712

7713

// Generated as internal constructor for term x64_ud2.

7714

pub fn constructor_x64_ud2<C: Context>(ctx: &mut C, arg0: &TrapCode) -> SideEffectNoResult {

7715

    let v1 = MInst::Ud2 {

7716

        trap_code: arg0.clone(),

7717

};

7718

    let v2 = SideEffectNoResult::Inst { inst: v1 };

7719

    // Rule at src/isa/x64/inst.isle line 4090.

7720

    return v2;

7721

7722

7723

// Generated as internal constructor for term x64_hlt.

7724

pub fn constructor_x64_hlt<C: Context>(ctx: &mut C) -> SideEffectNoResult {

7725

    let v1 = SideEffectNoResult::Inst { inst: MInst::Hlt };

7726

    // Rule at src/isa/x64/inst.isle line 4095.

7727

    return v1;

7728

7729

7730

// Generated as internal constructor for term x64_lzcnt.

7731

pub fn constructor_x64_lzcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {

7732

    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);

7733

    let v4 = constructor_unary_rm_r(ctx, &UnaryRmROpcode::Lzcnt, arg1, v3);

7734

    // Rule at src/isa/x64/inst.isle line 4100.

7735

    return v4;

7736

7737

7738

// Generated as internal constructor for term x64_tzcnt.

7739

pub fn constructor_x64_tzcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {

7740

    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);

7741

    let v4 = constructor_unary_rm_r(ctx, &UnaryRmROpcode::Tzcnt, arg1, v3);

7742

    // Rule at src/isa/x64/inst.isle line 4105.

7743

    return v4;

7744

7745

7746

// Generated as internal constructor for term x64_bsr.

7747

pub fn constructor_x64_bsr<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> ProducesFlags {

7748

    let v2 = C::temp_writable_gpr(ctx);

7749

    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);

7750

    let v5 = &C::gpr_to_gpr_mem(ctx, arg1);

7751

    let v7 = constructor_writable_gpr_to_r_reg(ctx, v2);

7752

    let v6 = MInst::UnaryRmR {

7753

        size: v3.clone(),

7754

        op: UnaryRmROpcode::Bsr,

7755

        src: v5.clone(),

7756

        dst: v2,

7757

};

7758

    let v8 = ProducesFlags::ProducesFlagsReturnsReg {

7759

        inst: v6,

7760

        result: v7,

7761

};

7762

    // Rule at src/isa/x64/inst.isle line 4110.

7763

    return v8;

7764

7765

7766

// Generated as internal constructor for term bsr_or_else.

7767

pub fn constructor_bsr_or_else<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: Gpr) -> Gpr {

7768

    let v3 = &constructor_x64_bsr(ctx, arg0, arg1);

7769

    let v4 = constructor_produces_flags_get_reg(ctx, v3);

7770

    let v5 = C::gpr_new(ctx, v4);

7771

    let v7 = &C::gpr_to_gpr_mem(ctx, arg2);

7772

    let v8 = &constructor_cmove(ctx, arg0, &CC::Z, v7, v5);

7773

    let v9 = &constructor_produces_flags_ignore(ctx, v3);

7774

    let v10 = constructor_with_flags_reg(ctx, v9, v8);

7775

    let v11 = C::gpr_new(ctx, v10);

7776

    // Rule at src/isa/x64/inst.isle line 4119.

7777

    return v11;

7778

7779

7780

// Generated as internal constructor for term x64_bsf.

7781

pub fn constructor_x64_bsf<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> ProducesFlags {

7782

    let v2 = C::temp_writable_gpr(ctx);

7783

    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);

7784

    let v5 = &C::gpr_to_gpr_mem(ctx, arg1);

7785

    let v7 = constructor_writable_gpr_to_r_reg(ctx, v2);

7786

    let v6 = MInst::UnaryRmR {

7787

        size: v3.clone(),

7788

        op: UnaryRmROpcode::Bsf,

7789

        src: v5.clone(),

7790

        dst: v2,

7791

};

7792

    let v8 = ProducesFlags::ProducesFlagsReturnsReg {

7793

        inst: v6,

7794

        result: v7,

7795

};

7796

    // Rule at src/isa/x64/inst.isle line 4130.

7797

    return v8;

7798

7799

7800

// Generated as internal constructor for term bsf_or_else.

7801

pub fn constructor_bsf_or_else<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: Gpr) -> Gpr {

7802

    let v3 = &constructor_x64_bsf(ctx, arg0, arg1);

7803

    let v4 = constructor_produces_flags_get_reg(ctx, v3);

7804

    let v5 = C::gpr_new(ctx, v4);

7805

    let v7 = &C::gpr_to_gpr_mem(ctx, arg2);

7806

    let v8 = &constructor_cmove(ctx, arg0, &CC::Z, v7, v5);

7807

    let v9 = &constructor_produces_flags_ignore(ctx, v3);

7808

    let v10 = constructor_with_flags_reg(ctx, v9, v8);

7809

    let v11 = C::gpr_new(ctx, v10);

7810

    // Rule at src/isa/x64/inst.isle line 4139.

7811

    return v11;

7812

7813

7814

// Generated as internal constructor for term x64_blsi.

7815

pub fn constructor_x64_blsi<C: Context>(ctx: &mut C, arg0: Type, arg1: &GprMem) -> Gpr {

7816

    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);

7817

    let v4 = constructor_unary_rm_r_vex(ctx, &UnaryRmRVexOpcode::Blsi, arg1, v3);

7818

    // Rule at src/isa/x64/inst.isle line 4150.

7819

    return v4;

7820

7821

7822

// Generated as internal constructor for term x64_blsmsk.

7823

pub fn constructor_x64_blsmsk<C: Context>(ctx: &mut C, arg0: Type, arg1: &GprMem) -> Gpr {

7824

    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);

7825

    let v4 = constructor_unary_rm_r_vex(ctx, &UnaryRmRVexOpcode::Blsmsk, arg1, v3);

7826

    // Rule at src/isa/x64/inst.isle line 4155.

7827

    return v4;

7828

7829

7830

// Generated as internal constructor for term x64_blsr.

7831

pub fn constructor_x64_blsr<C: Context>(ctx: &mut C, arg0: Type, arg1: &GprMem) -> Gpr {

7832

    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);

7833

    let v4 = constructor_unary_rm_r_vex(ctx, &UnaryRmRVexOpcode::Blsr, arg1, v3);

7834

    // Rule at src/isa/x64/inst.isle line 4160.

7835

    return v4;

7836

7837

7838

// Generated as internal constructor for term x64_sarx.

7839

pub fn constructor_x64_sarx<C: Context>(ctx: &mut C, arg0: Type, arg1: &GprMem, arg2: Gpr) -> Gpr {

7840

    let v4 = constructor_alu_rm_r_vex(ctx, arg0, &AluRmROpcode::Sarx, arg2, arg1);

7841

    // Rule at src/isa/x64/inst.isle line 4165.

7842

    return v4;

7843

7844

7845

// Generated as internal constructor for term x64_shrx.

7846

pub fn constructor_x64_shrx<C: Context>(ctx: &mut C, arg0: Type, arg1: &GprMem, arg2: Gpr) -> Gpr {

7847

    let v4 = constructor_alu_rm_r_vex(ctx, arg0, &AluRmROpcode::Shrx, arg2, arg1);

7848

    // Rule at src/isa/x64/inst.isle line 4170.

7849

    return v4;

7850

7851

7852

// Generated as internal constructor for term x64_shlx.

7853

pub fn constructor_x64_shlx<C: Context>(ctx: &mut C, arg0: Type, arg1: &GprMem, arg2: Gpr) -> Gpr {

7854

    let v4 = constructor_alu_rm_r_vex(ctx, arg0, &AluRmROpcode::Shlx, arg2, arg1);

7855

    // Rule at src/isa/x64/inst.isle line 4175.

7856

    return v4;

7857

7858

7859

// Generated as internal constructor for term x64_rorx.

7860

pub fn constructor_x64_rorx<C: Context>(ctx: &mut C, arg0: Type, arg1: &GprMem, arg2: u8) -> Gpr {

7861

    let v4 = &C::operand_size_of_type_32_64(ctx, arg0);

7862

    let v5 = constructor_unary_rm_r_imm_vex(ctx, &UnaryRmRImmVexOpcode::Rorx, arg1, v4, arg2);

7863

    // Rule at src/isa/x64/inst.isle line 4180.

7864

    return v5;

7865

7866

7867

// Generated as internal constructor for term x64_popcnt.

7868

pub fn constructor_x64_popcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {

7869

    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);

7870

    let v4 = constructor_unary_rm_r(ctx, &UnaryRmROpcode::Popcnt, arg1, v3);

7871

    // Rule at src/isa/x64/inst.isle line 4188.

7872

    return v4;

7873

7874

7875

// Generated as internal constructor for term x64_minss.

7876

pub fn constructor_x64_minss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

7877

    let v4 = C::use_avx(ctx);

7878

    if v4 == true {

7879

        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

7880

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vminss, arg0, v6);

7881

        // Rule at src/isa/x64/inst.isle line 4195.

7882

        return v7;

7883

7884

    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Minss, arg0, arg1);

7885

    // Rule at src/isa/x64/inst.isle line 4193.

7886

    return v3;

7887

7888

7889

// Generated as internal constructor for term x64_minsd.

7890

pub fn constructor_x64_minsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

7891

    let v4 = C::use_avx(ctx);

7892

    if v4 == true {

7893

        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

7894

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vminsd, arg0, v6);

7895

        // Rule at src/isa/x64/inst.isle line 4203.

7896

        return v7;

7897

7898

    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Minsd, arg0, arg1);

7899

    // Rule at src/isa/x64/inst.isle line 4201.

7900

    return v3;

7901

7902

7903

// Generated as internal constructor for term x64_minps.

7904

pub fn constructor_x64_minps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

7905

    let v5 = C::use_avx(ctx);

7906

    if v5 == true {

7907

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

7908

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vminps, arg0, v7);

7909

        // Rule at src/isa/x64/inst.isle line 4211.

7910

        return v8;

7911

7912

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

7913

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Minps, arg0, v3);

7914

    // Rule at src/isa/x64/inst.isle line 4209.

7915

    return v4;

7916

7917

7918

// Generated as internal constructor for term x64_minpd.

7919

pub fn constructor_x64_minpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

7920

    let v5 = C::use_avx(ctx);

7921

    if v5 == true {

7922

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

7923

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vminpd, arg0, v7);

7924

        // Rule at src/isa/x64/inst.isle line 4219.

7925

        return v8;

7926

7927

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

7928

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Minpd, arg0, v3);

7929

    // Rule at src/isa/x64/inst.isle line 4217.

7930

    return v4;

7931

7932

7933

// Generated as internal constructor for term x64_maxss.

7934

pub fn constructor_x64_maxss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

7935

    let v4 = C::use_avx(ctx);

7936

    if v4 == true {

7937

        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

7938

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmaxss, arg0, v6);

7939

        // Rule at src/isa/x64/inst.isle line 4227.

7940

        return v7;

7941

7942

    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Maxss, arg0, arg1);

7943

    // Rule at src/isa/x64/inst.isle line 4225.

7944

    return v3;

7945

7946

7947

// Generated as internal constructor for term x64_maxsd.

7948

pub fn constructor_x64_maxsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

7949

    let v4 = C::use_avx(ctx);

7950

    if v4 == true {

7951

        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

7952

        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmaxsd, arg0, v6);

7953

        // Rule at src/isa/x64/inst.isle line 4235.

7954

        return v7;

7955

7956

    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Maxsd, arg0, arg1);

7957

    // Rule at src/isa/x64/inst.isle line 4233.

7958

    return v3;

7959

7960

7961

// Generated as internal constructor for term x64_maxps.

7962

pub fn constructor_x64_maxps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

7963

    let v5 = C::use_avx(ctx);

7964

    if v5 == true {

7965

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

7966

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmaxps, arg0, v7);

7967

        // Rule at src/isa/x64/inst.isle line 4243.

7968

        return v8;

7969

7970

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

7971

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Maxps, arg0, v3);

7972

    // Rule at src/isa/x64/inst.isle line 4241.

7973

    return v4;

7974

7975

7976

// Generated as internal constructor for term x64_maxpd.

7977

pub fn constructor_x64_maxpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

7978

    let v5 = C::use_avx(ctx);

7979

    if v5 == true {

7980

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

7981

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmaxpd, arg0, v7);

7982

        // Rule at src/isa/x64/inst.isle line 4251.

7983

        return v8;

7984

7985

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

7986

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Maxpd, arg0, v3);

7987

    // Rule at src/isa/x64/inst.isle line 4249.

7988

    return v4;

7989

7990

7991

// Generated as internal constructor for term x64_vfmadd213.

7992

pub fn constructor_x64_vfmadd213<C: Context>(

7993

    ctx: &mut C,

7994

    arg0: Type,

7995

    arg1: Xmm,

7996

    arg2: Xmm,

7997

    arg3: &XmmMem,

7998

) -> Xmm {

7999

    match arg0 {

8000

        F32 => {

8001

            let v5 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfmadd213ss, arg1, arg2, arg3);

8002

            // Rule at src/isa/x64/inst.isle line 4257.

8003

            return v5;

8004

8005

        F64 => {

8006

            let v7 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfmadd213sd, arg1, arg2, arg3);

8007

            // Rule at src/isa/x64/inst.isle line 4258.

8008

            return v7;

8009

8010

        F32X4 => {

8011

            let v9 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfmadd213ps, arg1, arg2, arg3);

8012

            // Rule at src/isa/x64/inst.isle line 4259.

8013

            return v9;

8014

8015

        F64X2 => {

8016

            let v11 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfmadd213pd, arg1, arg2, arg3);

8017

            // Rule at src/isa/x64/inst.isle line 4260.

8018

            return v11;

8019

8020

        _ => {}

8021

8022

    unreachable!(

8023

        "no rule matched for term {} at {}; should it be partial?",

8024

        "x64_vfmadd213", "src/isa/x64/inst.isle line 4256"

8025

8026

8027

8028

// Generated as internal constructor for term x64_vfmadd132.

8029

pub fn constructor_x64_vfmadd132<C: Context>(

8030

    ctx: &mut C,

8031

    arg0: Type,

8032

    arg1: Xmm,

8033

    arg2: Xmm,

8034

    arg3: &XmmMem,

8035

) -> Xmm {

8036

    match arg0 {

8037

        F32 => {

8038

            let v5 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfmadd132ss, arg1, arg2, arg3);

8039

            // Rule at src/isa/x64/inst.isle line 4264.

8040

            return v5;

8041

8042

        F64 => {

8043

            let v7 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfmadd132sd, arg1, arg2, arg3);

8044

            // Rule at src/isa/x64/inst.isle line 4265.

8045

            return v7;

8046

8047

        F32X4 => {

8048

            let v9 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfmadd132ps, arg1, arg2, arg3);

8049

            // Rule at src/isa/x64/inst.isle line 4266.

8050

            return v9;

8051

8052

        F64X2 => {

8053

            let v11 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfmadd132pd, arg1, arg2, arg3);

8054

            // Rule at src/isa/x64/inst.isle line 4267.

8055

            return v11;

8056

8057

        _ => {}

8058

8059

    unreachable!(

8060

        "no rule matched for term {} at {}; should it be partial?",

8061

        "x64_vfmadd132", "src/isa/x64/inst.isle line 4263"

8062

8063

8064

8065

// Generated as internal constructor for term x64_vfnmadd213.

8066

pub fn constructor_x64_vfnmadd213<C: Context>(

8067

    ctx: &mut C,

8068

    arg0: Type,

8069

    arg1: Xmm,

8070

    arg2: Xmm,

8071

    arg3: &XmmMem,

8072

) -> Xmm {

8073

    match arg0 {

8074

        F32 => {

8075

            let v5 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfnmadd213ss, arg1, arg2, arg3);

8076

            // Rule at src/isa/x64/inst.isle line 4271.

8077

            return v5;

8078

8079

        F64 => {

8080

            let v7 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfnmadd213sd, arg1, arg2, arg3);

8081

            // Rule at src/isa/x64/inst.isle line 4272.

8082

            return v7;

8083

8084

        F32X4 => {

8085

            let v9 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfnmadd213ps, arg1, arg2, arg3);

8086

            // Rule at src/isa/x64/inst.isle line 4273.

8087

            return v9;

8088

8089

        F64X2 => {

8090

            let v11 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfnmadd213pd, arg1, arg2, arg3);

8091

            // Rule at src/isa/x64/inst.isle line 4274.

8092

            return v11;

8093

8094

        _ => {}

8095

8096

    unreachable!(

8097

        "no rule matched for term {} at {}; should it be partial?",

8098

        "x64_vfnmadd213", "src/isa/x64/inst.isle line 4270"

8099

8100

8101

8102

// Generated as internal constructor for term x64_vfnmadd132.

8103

pub fn constructor_x64_vfnmadd132<C: Context>(

8104

    ctx: &mut C,

8105

    arg0: Type,

8106

    arg1: Xmm,

8107

    arg2: Xmm,

8108

    arg3: &XmmMem,

8109

) -> Xmm {

8110

    match arg0 {

8111

        F32 => {

8112

            let v5 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfnmadd132ss, arg1, arg2, arg3);

8113

            // Rule at src/isa/x64/inst.isle line 4278.

8114

            return v5;

8115

8116

        F64 => {

8117

            let v7 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfnmadd132sd, arg1, arg2, arg3);

8118

            // Rule at src/isa/x64/inst.isle line 4279.

8119

            return v7;

8120

8121

        F32X4 => {

8122

            let v9 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfnmadd132ps, arg1, arg2, arg3);

8123

            // Rule at src/isa/x64/inst.isle line 4280.

8124

            return v9;

8125

8126

        F64X2 => {

8127

            let v11 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfnmadd132pd, arg1, arg2, arg3);

8128

            // Rule at src/isa/x64/inst.isle line 4281.

8129

            return v11;

8130

8131

        _ => {}

8132

8133

    unreachable!(

8134

        "no rule matched for term {} at {}; should it be partial?",

8135

        "x64_vfnmadd132", "src/isa/x64/inst.isle line 4277"

8136

8137

8138

8139

// Generated as internal constructor for term x64_sqrtss.

8140

pub fn constructor_x64_sqrtss<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

8141

    let v3 = C::use_avx(ctx);

8142

    if v3 == true {

8143

        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vsqrtss, arg0);

8144

        // Rule at src/isa/x64/inst.isle line 4286.

8145

        return v5;

8146

8147

    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Sqrtss, arg0);

8148

    // Rule at src/isa/x64/inst.isle line 4285.

8149

    return v2;

8150

8151

8152

// Generated as internal constructor for term x64_sqrtsd.

8153

pub fn constructor_x64_sqrtsd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

8154

    let v3 = C::use_avx(ctx);

8155

    if v3 == true {

8156

        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vsqrtsd, arg0);

8157

        // Rule at src/isa/x64/inst.isle line 4293.

8158

        return v5;

8159

8160

    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Sqrtsd, arg0);

8161

    // Rule at src/isa/x64/inst.isle line 4292.

8162

    return v2;

8163

8164

8165

// Generated as internal constructor for term x64_sqrtps.

8166

pub fn constructor_x64_sqrtps<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

8167

    let v4 = C::use_avx(ctx);

8168

    if v4 == true {

8169

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vsqrtps, arg0);

8170

        // Rule at src/isa/x64/inst.isle line 4300.

8171

        return v6;

8172

8173

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

8174

    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Sqrtps, v2);

8175

    // Rule at src/isa/x64/inst.isle line 4299.

8176

    return v3;

8177

8178

8179

// Generated as internal constructor for term x64_sqrtpd.

8180

pub fn constructor_x64_sqrtpd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

8181

    let v4 = C::use_avx(ctx);

8182

    if v4 == true {

8183

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vsqrtpd, arg0);

8184

        // Rule at src/isa/x64/inst.isle line 4307.

8185

        return v6;

8186

8187

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

8188

    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Sqrtpd, v2);

8189

    // Rule at src/isa/x64/inst.isle line 4306.

8190

    return v3;

8191

8192

8193

// Generated as internal constructor for term x64_cvtss2sd.

8194

pub fn constructor_x64_cvtss2sd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

8195

    let v3 = C::use_avx(ctx);

8196

    if v3 == true {

8197

        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vcvtss2sd, arg0);

8198

        // Rule at src/isa/x64/inst.isle line 4314.

8199

        return v5;

8200

8201

    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Cvtss2sd, arg0);

8202

    // Rule at src/isa/x64/inst.isle line 4313.

8203

    return v2;

8204

8205

8206

// Generated as internal constructor for term x64_cvtsd2ss.

8207

pub fn constructor_x64_cvtsd2ss<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

8208

    let v3 = C::use_avx(ctx);

8209

    if v3 == true {

8210

        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vcvtsd2ss, arg0);

8211

        // Rule at src/isa/x64/inst.isle line 4321.

8212

        return v5;

8213

8214

    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Cvtsd2ss, arg0);

8215

    // Rule at src/isa/x64/inst.isle line 4320.

8216

    return v2;

8217

8218

8219

// Generated as internal constructor for term x64_cvtdq2ps.

8220

pub fn constructor_x64_cvtdq2ps<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

8221

    let v4 = C::use_avx(ctx);

8222

    if v4 == true {

8223

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vcvtdq2ps, arg0);

8224

        // Rule at src/isa/x64/inst.isle line 4328.

8225

        return v6;

8226

8227

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

8228

    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Cvtdq2ps, v2);

8229

    // Rule at src/isa/x64/inst.isle line 4327.

8230

    return v3;

8231

8232

8233

// Generated as internal constructor for term x64_cvtps2pd.

8234

pub fn constructor_x64_cvtps2pd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

8235

    let v4 = C::use_avx(ctx);

8236

    if v4 == true {

8237

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vcvtps2pd, arg0);

8238

        // Rule at src/isa/x64/inst.isle line 4335.

8239

        return v6;

8240

8241

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

8242

    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Cvtps2pd, v2);

8243

    // Rule at src/isa/x64/inst.isle line 4334.

8244

    return v3;

8245

8246

8247

// Generated as internal constructor for term x64_cvtpd2ps.

8248

pub fn constructor_x64_cvtpd2ps<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

8249

    let v4 = C::use_avx(ctx);

8250

    if v4 == true {

8251

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vcvtpd2ps, arg0);

8252

        // Rule at src/isa/x64/inst.isle line 4342.

8253

        return v6;

8254

8255

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

8256

    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Cvtpd2ps, v2);

8257

    // Rule at src/isa/x64/inst.isle line 4341.

8258

    return v3;

8259

8260

8261

// Generated as internal constructor for term x64_cvtdq2pd.

8262

pub fn constructor_x64_cvtdq2pd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

8263

    let v4 = C::use_avx(ctx);

8264

    if v4 == true {

8265

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vcvtdq2pd, arg0);

8266

        // Rule at src/isa/x64/inst.isle line 4349.

8267

        return v6;

8268

8269

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

8270

    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Cvtdq2pd, v2);

8271

    // Rule at src/isa/x64/inst.isle line 4348.

8272

    return v3;

8273

8274

8275

// Generated as internal constructor for term x64_cvtsi2ss.

8276

pub fn constructor_x64_cvtsi2ss<C: Context>(

8277

    ctx: &mut C,

8278

    arg0: Type,

8279

    arg1: Xmm,

8280

    arg2: &GprMem,

8281

) -> Xmm {

8282

    let v6 = C::use_avx(ctx);

8283

    if v6 == true {

8284

        let v4 = &C::raw_operand_size_of_type(ctx, arg0);

8285

        let v8 = constructor_cvt_int_to_float_vex(ctx, &AvxOpcode::Vcvtsi2ss, arg1, arg2, v4);

8286

        // Rule at src/isa/x64/inst.isle line 4357.

8287

        return v8;

8288

8289

    let v4 = &C::raw_operand_size_of_type(ctx, arg0);

8290

    let v5 = constructor_cvt_int_to_float(ctx, &SseOpcode::Cvtsi2ss, arg1, arg2, v4);

8291

    // Rule at src/isa/x64/inst.isle line 4355.

8292

    return v5;

8293

8294

8295

// Generated as internal constructor for term x64_cvtsi2sd.

8296

pub fn constructor_x64_cvtsi2sd<C: Context>(

8297

    ctx: &mut C,

8298

    arg0: Type,

8299

    arg1: Xmm,

8300

    arg2: &GprMem,

8301

) -> Xmm {

8302

    let v6 = C::use_avx(ctx);

8303

    if v6 == true {

8304

        let v4 = &C::raw_operand_size_of_type(ctx, arg0);

8305

        let v8 = constructor_cvt_int_to_float_vex(ctx, &AvxOpcode::Vcvtsi2sd, arg1, arg2, v4);

8306

        // Rule at src/isa/x64/inst.isle line 4365.

8307

        return v8;

8308

8309

    let v4 = &C::raw_operand_size_of_type(ctx, arg0);

8310

    let v5 = constructor_cvt_int_to_float(ctx, &SseOpcode::Cvtsi2sd, arg1, arg2, v4);

8311

    // Rule at src/isa/x64/inst.isle line 4363.

8312

    return v5;

8313

8314

8315

// Generated as internal constructor for term x64_cvttps2dq.

8316

pub fn constructor_x64_cvttps2dq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

8317

    let v4 = C::use_avx(ctx);

8318

    if v4 == true {

8319

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vcvttps2dq, arg0);

8320

        // Rule at src/isa/x64/inst.isle line 4373.

8321

        return v6;

8322

8323

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

8324

    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Cvttps2dq, v2);

8325

    // Rule at src/isa/x64/inst.isle line 4371.

8326

    return v3;

8327

8328

8329

// Generated as internal constructor for term x64_cvttpd2dq.

8330

pub fn constructor_x64_cvttpd2dq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

8331

    let v4 = C::use_avx(ctx);

8332

    if v4 == true {

8333

        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vcvttpd2dq, arg0);

8334

        // Rule at src/isa/x64/inst.isle line 4381.

8335

        return v6;

8336

8337

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);

8338

    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Cvttpd2dq, v2);

8339

    // Rule at src/isa/x64/inst.isle line 4379.

8340

    return v3;

8341

8342

8343

// Generated as internal constructor for term x64_pcmpeq.

8344

pub fn constructor_x64_pcmpeq<C: Context>(

8345

    ctx: &mut C,

8346

    arg0: Type,

8347

    arg1: Xmm,

8348

    arg2: &XmmMem,

8349

) -> Xmm {

8350

    match arg0 {

8351

        I8X16 => {

8352

            let v3 = constructor_x64_pcmpeqb(ctx, arg1, arg2);

8353

            // Rule at src/isa/x64/inst.isle line 4387.

8354

            return v3;

8355

8356

        I16X8 => {

8357

            let v4 = constructor_x64_pcmpeqw(ctx, arg1, arg2);

8358

            // Rule at src/isa/x64/inst.isle line 4388.

8359

            return v4;

8360

8361

        I32X4 => {

8362

            let v5 = constructor_x64_pcmpeqd(ctx, arg1, arg2);

8363

            // Rule at src/isa/x64/inst.isle line 4389.

8364

            return v5;

8365

8366

        I64X2 => {

8367

            let v6 = C::use_sse41(ctx);

8368

            if v6 == true {

8369

                let v7 = constructor_x64_pcmpeqq(ctx, arg1, arg2);

8370

                // Rule at src/isa/x64/inst.isle line 4390.

8371

                return v7;

8372

8373

            let v5 = constructor_x64_pcmpeqd(ctx, arg1, arg2);

8374

            let v8 = &C::xmm_to_xmm_mem(ctx, v5);

8375

            let v10 = constructor_x64_pshufd(ctx, v8, 0xB1);

8376

            let v11 = &C::xmm_to_xmm_mem(ctx, v10);

8377

            let v12 = constructor_x64_pand(ctx, v5, v11);

8378

            // Rule at src/isa/x64/inst.isle line 4399.

8379

            return v12;

8380

8381

        _ => {}

8382

8383

    unreachable!(

8384

        "no rule matched for term {} at {}; should it be partial?",

8385

        "x64_pcmpeq", "src/isa/x64/inst.isle line 4386"

8386

8387

8388

8389

// Generated as internal constructor for term x64_pcmpeqb.

8390

pub fn constructor_x64_pcmpeqb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

8391

    let v5 = C::use_avx(ctx);

8392

    if v5 == true {

8393

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

8394

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpcmpeqb, arg0, v7);

8395

        // Rule at src/isa/x64/inst.isle line 4406.

8396

        return v8;

8397

8398

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

8399

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pcmpeqb, arg0, v3);

8400

    // Rule at src/isa/x64/inst.isle line 4405.

8401

    return v4;

8402

8403

8404

// Generated as internal constructor for term x64_pcmpeqw.

8405

pub fn constructor_x64_pcmpeqw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

8406

    let v5 = C::use_avx(ctx);

8407

    if v5 == true {

8408

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

8409

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpcmpeqw, arg0, v7);

8410

        // Rule at src/isa/x64/inst.isle line 4411.

8411

        return v8;

8412

8413

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

8414

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pcmpeqw, arg0, v3);

8415

    // Rule at src/isa/x64/inst.isle line 4410.

8416

    return v4;

8417

8418

8419

// Generated as internal constructor for term x64_pcmpeqd.

8420

pub fn constructor_x64_pcmpeqd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

8421

    let v5 = C::use_avx(ctx);

8422

    if v5 == true {

8423

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

8424

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpcmpeqd, arg0, v7);

8425

        // Rule at src/isa/x64/inst.isle line 4416.

8426

        return v8;

8427

8428

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

8429

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pcmpeqd, arg0, v3);

8430

    // Rule at src/isa/x64/inst.isle line 4415.

8431

    return v4;

8432

8433

8434

// Generated as internal constructor for term x64_pcmpeqq.

8435

pub fn constructor_x64_pcmpeqq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

8436

    let v5 = C::use_avx(ctx);

8437

    if v5 == true {

8438

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

8439

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpcmpeqq, arg0, v7);

8440

        // Rule at src/isa/x64/inst.isle line 4421.

8441

        return v8;

8442

8443

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

8444

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pcmpeqq, arg0, v3);

8445

    // Rule at src/isa/x64/inst.isle line 4420.

8446

    return v4;

8447

8448

8449

// Generated as internal constructor for term x64_pcmpgt.

8450

pub fn constructor_x64_pcmpgt<C: Context>(

8451

    ctx: &mut C,

8452

    arg0: Type,

8453

    arg1: Xmm,

8454

    arg2: &XmmMem,

8455

) -> Xmm {

8456

    match arg0 {

8457

        I8X16 => {

8458

            let v3 = constructor_x64_pcmpgtb(ctx, arg1, arg2);

8459

            // Rule at src/isa/x64/inst.isle line 4427.

8460

            return v3;

8461

8462

        I16X8 => {

8463

            let v4 = constructor_x64_pcmpgtw(ctx, arg1, arg2);

8464

            // Rule at src/isa/x64/inst.isle line 4428.

8465

            return v4;

8466

8467

        I32X4 => {

8468

            let v5 = constructor_x64_pcmpgtd(ctx, arg1, arg2);

8469

            // Rule at src/isa/x64/inst.isle line 4429.

8470

            return v5;

8471

8472

        I64X2 => {

8473

            let v6 = C::use_sse42(ctx);

8474

            if v6 == true {

8475

                let v7 = constructor_x64_pcmpgtq(ctx, arg1, arg2);

8476

                // Rule at src/isa/x64/inst.isle line 4433.

8477

                return v7;

8478

8479

            let v9 = C::emit_u128_le_const(ctx, 0x800000000000000080000000);

8480

            let v10 = &constructor_const_to_xmm_mem(ctx, v9);

8481

            let v11 = constructor_x64_movdqu_load(ctx, v10);

8482

            let v12 = &C::xmm_to_xmm_mem(ctx, arg1);

8483

            let v13 = constructor_x64_pxor(ctx, v11, v12);

8484

            let v14 = constructor_x64_pxor(ctx, v11, arg2);

8485

            let v15 = &C::xmm_to_xmm_mem(ctx, v14);

8486

            let v16 = constructor_x64_pcmpgtd(ctx, v13, v15);

8487

            let v17 = &C::xmm_to_xmm_mem(ctx, v16);

8488

            let v19 = constructor_x64_pshufd(ctx, v17, 0xA0);

8489

            let v20 = &C::xmm_to_xmm_mem(ctx, v16);

8490

            let v22 = constructor_x64_pshufd(ctx, v20, 0xF5);

8491

            let v23 = &C::xmm_to_xmm_mem(ctx, v14);

8492

            let v24 = constructor_x64_pcmpeqd(ctx, v13, v23);

8493

            let v25 = &C::xmm_to_xmm_mem(ctx, v24);

8494

            let v26 = constructor_x64_pshufd(ctx, v25, 0xF5);

8495

            let v27 = &C::xmm_to_xmm_mem(ctx, v26);

8496

            let v28 = constructor_x64_pand(ctx, v19, v27);

8497

            let v29 = &C::xmm_to_xmm_mem(ctx, v22);

8498

            let v30 = constructor_x64_por(ctx, v28, v29);

8499

            // Rule at src/isa/x64/inst.isle line 4462.

8500

            return v30;

8501

8502

        _ => {}

8503

8504

    unreachable!(

8505

        "no rule matched for term {} at {}; should it be partial?",

8506

        "x64_pcmpgt", "src/isa/x64/inst.isle line 4426"

8507

8508

8509

8510

// Generated as internal constructor for term x64_pcmpgtb.

8511

pub fn constructor_x64_pcmpgtb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

8512

    let v5 = C::use_avx(ctx);

8513

    if v5 == true {

8514

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

8515

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpcmpgtb, arg0, v7);

8516

        // Rule at src/isa/x64/inst.isle line 4478.

8517

        return v8;

8518

8519

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

8520

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pcmpgtb, arg0, v3);

8521

    // Rule at src/isa/x64/inst.isle line 4477.

8522

    return v4;

8523

8524

8525

// Generated as internal constructor for term x64_pcmpgtw.

8526

pub fn constructor_x64_pcmpgtw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

8527

    let v5 = C::use_avx(ctx);

8528

    if v5 == true {

8529

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

8530

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpcmpgtw, arg0, v7);

8531

        // Rule at src/isa/x64/inst.isle line 4483.

8532

        return v8;

8533

8534

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

8535

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pcmpgtw, arg0, v3);

8536

    // Rule at src/isa/x64/inst.isle line 4482.

8537

    return v4;

8538

8539

8540

// Generated as internal constructor for term x64_pcmpgtd.

8541

pub fn constructor_x64_pcmpgtd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

8542

    let v5 = C::use_avx(ctx);

8543

    if v5 == true {

8544

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

8545

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpcmpgtd, arg0, v7);

8546

        // Rule at src/isa/x64/inst.isle line 4488.

8547

        return v8;

8548

8549

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

8550

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pcmpgtd, arg0, v3);

8551

    // Rule at src/isa/x64/inst.isle line 4487.

8552

    return v4;

8553

8554

8555

// Generated as internal constructor for term x64_pcmpgtq.

8556

pub fn constructor_x64_pcmpgtq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {

8557

    let v5 = C::use_avx(ctx);

8558

    if v5 == true {

8559

        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);

8560

        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpcmpgtq, arg0, v7);

8561

        // Rule at src/isa/x64/inst.isle line 4493.

8562

        return v8;

8563

8564

    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);

8565

    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pcmpgtq, arg0, v3);

8566

    // Rule at src/isa/x64/inst.isle line 4492.

8567

    return v4;

8568

8569

8570

// Generated as internal constructor for term alu_rm.

8571

pub fn constructor_alu_rm<C: Context>(

8572

    ctx: &mut C,

8573

    arg0: Type,

8574

    arg1: &AluRmiROpcode,

8575

    arg2: &Amode,

8576

    arg3: Gpr,

8577

) -> SideEffectNoResult {

8578

    let v4 = &C::operand_size_of_type_32_64(ctx, arg0);

8579

    let v5 = &C::amode_to_synthetic_amode(ctx, arg2);

8580

    let v6 = MInst::AluRM {

8581

        size: v4.clone(),

8582

        op: arg1.clone(),

8583

        src1_dst: v5.clone(),

8584

        src2: arg3,

8585

};

8586

    let v7 = SideEffectNoResult::Inst { inst: v6 };

8587

    // Rule at src/isa/x64/inst.isle line 4499.

8588

    return v7;

8589

8590

8591

// Generated as internal constructor for term x64_add_mem.

8592

pub fn constructor_x64_add_mem<C: Context>(

8593

    ctx: &mut C,

8594

    arg0: Type,

8595

    arg1: &Amode,

8596

    arg2: Gpr,

8597

) -> SideEffectNoResult {

8598

    let v4 = &constructor_alu_rm(ctx, arg0, &AluRmiROpcode::Add, arg1, arg2);

8599

    // Rule at src/isa/x64/inst.isle line 4504.

8600

    return v4.clone();

8601

8602

8603

// Generated as internal constructor for term x64_sub_mem.

8604

pub fn constructor_x64_sub_mem<C: Context>(

8605

    ctx: &mut C,

8606

    arg0: Type,

8607

    arg1: &Amode,

8608

    arg2: Gpr,

8609

) -> SideEffectNoResult {

8610

    let v4 = &constructor_alu_rm(ctx, arg0, &AluRmiROpcode::Sub, arg1, arg2);

8611

    // Rule at src/isa/x64/inst.isle line 4508.

8612

    return v4.clone();

8613

8614

8615

// Generated as internal constructor for term x64_and_mem.

8616

pub fn constructor_x64_and_mem<C: Context>(

8617

    ctx: &mut C,

8618

    arg0: Type,

8619

    arg1: &Amode,

8620

    arg2: Gpr,

8621

) -> SideEffectNoResult {

8622

    let v4 = &constructor_alu_rm(ctx, arg0, &AluRmiROpcode::And, arg1, arg2);

8623

    // Rule at src/isa/x64/inst.isle line 4512.

8624

    return v4.clone();

8625

8626

8627

// Generated as internal constructor for term x64_or_mem.

8628

pub fn constructor_x64_or_mem<C: Context>(

8629

    ctx: &mut C,

8630

    arg0: Type,

8631

    arg1: &Amode,

8632

    arg2: Gpr,

8633

) -> SideEffectNoResult {

8634

    let v4 = &constructor_alu_rm(ctx, arg0, &AluRmiROpcode::Or, arg1, arg2);

8635

    // Rule at src/isa/x64/inst.isle line 4516.

8636

    return v4.clone();

8637

8638

8639

// Generated as internal constructor for term x64_xor_mem.

8640

pub fn constructor_x64_xor_mem<C: Context>(

8641

    ctx: &mut C,

8642

    arg0: Type,

8643

    arg1: &Amode,

8644

    arg2: Gpr,

8645

) -> SideEffectNoResult {

8646

    let v4 = &constructor_alu_rm(ctx, arg0, &AluRmiROpcode::Xor, arg1, arg2);

8647

    // Rule at src/isa/x64/inst.isle line 4520.

8648

    return v4.clone();

8649

8650

8651

// Generated as internal constructor for term trap_if.

8652

pub fn constructor_trap_if<C: Context>(ctx: &mut C, arg0: &CC, arg1: &TrapCode) -> ConsumesFlags {

8653

    let v2 = MInst::TrapIf {

8654

        cc: arg0.clone(),

8655

        trap_code: arg1.clone(),

8656

};

8657

    let v3 = ConsumesFlags::ConsumesFlagsSideEffect { inst: v2 };

8658

    // Rule at src/isa/x64/inst.isle line 4525.

8659

    return v3;

8660

8661

8662

// Generated as internal constructor for term trap_if_and.

8663

pub fn constructor_trap_if_and<C: Context>(

8664

    ctx: &mut C,

8665

    arg0: &CC,

8666

    arg1: &CC,

8667

    arg2: &TrapCode,

8668

) -> ConsumesFlags {

8669

    let v3 = MInst::TrapIfAnd {

8670

        cc1: arg0.clone(),

8671

        cc2: arg1.clone(),

8672

        trap_code: arg2.clone(),

8673

};

8674

    let v4 = ConsumesFlags::ConsumesFlagsSideEffect { inst: v3 };

8675

    // Rule at src/isa/x64/inst.isle line 4530.

8676

    return v4;

8677

8678

8679

// Generated as internal constructor for term trap_if_or.

8680

pub fn constructor_trap_if_or<C: Context>(

8681

    ctx: &mut C,

8682

    arg0: &CC,

8683

    arg1: &CC,

8684

    arg2: &TrapCode,

8685

) -> ConsumesFlags {

8686

    let v3 = MInst::TrapIfOr {

8687

        cc1: arg0.clone(),

8688

        cc2: arg1.clone(),

8689

        trap_code: arg2.clone(),

8690

};

8691

    let v4 = ConsumesFlags::ConsumesFlagsSideEffect { inst: v3 };

8692

    // Rule at src/isa/x64/inst.isle line 4535.

8693

    return v4;

8694

8695

8696

// Generated as internal constructor for term trap_if_icmp.

8697

pub fn constructor_trap_if_icmp<C: Context>(

8698

    ctx: &mut C,

8699

    arg0: &IcmpCondResult,

8700

    arg1: &TrapCode,

8701

) -> SideEffectNoResult {

8702

    if let &IcmpCondResult::Condition {

8703

        producer: ref v1,

8704

        cc: ref v2,

8705

    } = arg0

8706

8707

        let v4 = &constructor_trap_if(ctx, v2, arg1);

8708

        let v5 = &constructor_with_flags_side_effect(ctx, v1, v4);

8709

        // Rule at src/isa/x64/inst.isle line 4539.

8710

        return v5.clone();

8711

8712

    unreachable!(

8713

        "no rule matched for term {} at {}; should it be partial?",

8714

        "trap_if_icmp", "src/isa/x64/inst.isle line 4538"

8715

8716

8717

8718

// Generated as internal constructor for term trap_if_fcmp.

8719

pub fn constructor_trap_if_fcmp<C: Context>(

8720

    ctx: &mut C,

8721

    arg0: &FcmpCondResult,

8722

    arg1: &TrapCode,

8723

) -> SideEffectNoResult {

8724

    match arg0 {

8725

        &FcmpCondResult::Condition {

8726

            producer: ref v1,

8727

            cc: ref v2,

8728

        } => {

8729

            let v4 = &constructor_trap_if(ctx, v2, arg1);

8730

            let v5 = &constructor_with_flags_side_effect(ctx, v1, v4);

8731

            // Rule at src/isa/x64/inst.isle line 4543.

8732

            return v5.clone();

8733

8734

        &FcmpCondResult::AndCondition {

8735

            producer: ref v6,

8736

            cc1: ref v7,

8737

            cc2: ref v8,

8738

        } => {

8739

            let v9 = &constructor_trap_if_and(ctx, v7, v8, arg1);

8740

            let v10 = &constructor_with_flags_side_effect(ctx, v6, v9);

8741

            // Rule at src/isa/x64/inst.isle line 4545.

8742

            return v10.clone();

8743

8744

        &FcmpCondResult::OrCondition {

8745

            producer: ref v11,

8746

            cc1: ref v12,

8747

            cc2: ref v13,

8748

        } => {

8749

            let v14 = &constructor_trap_if_or(ctx, v12, v13, arg1);

8750

            let v15 = &constructor_with_flags_side_effect(ctx, v11, v14);

8751

            // Rule at src/isa/x64/inst.isle line 4547.

8752

            return v15.clone();

8753

8754

        _ => {}

8755

8756

    unreachable!(

8757

        "no rule matched for term {} at {}; should it be partial?",

8758

        "trap_if_fcmp", "src/isa/x64/inst.isle line 4542"

8759

8760

8761

8762

// Generated as internal constructor for term x64_movddup.

8763

pub fn constructor_x64_movddup<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

8764

    let v3 = C::use_avx(ctx);

8765

    if v3 == true {

8766

        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vmovddup, arg0);

8767

        // Rule at src/isa/x64/inst.isle line 4554.

8768

        return v5;

8769

8770

    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Movddup, arg0);

8771

    // Rule at src/isa/x64/inst.isle line 4552.

8772

    return v2;

8773

8774

8775

// Generated as internal constructor for term x64_vpbroadcastb.

8776

pub fn constructor_x64_vpbroadcastb<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

8777

    let v2 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpbroadcastb, arg0);

8778

    // Rule at src/isa/x64/inst.isle line 4560.

8779

    return v2;

8780

8781

8782

// Generated as internal constructor for term x64_vpbroadcastw.

8783

pub fn constructor_x64_vpbroadcastw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

8784

    let v2 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpbroadcastw, arg0);

8785

    // Rule at src/isa/x64/inst.isle line 4565.

8786

    return v2;

8787

8788

8789

// Generated as internal constructor for term x64_vpbroadcastd.

8790

pub fn constructor_x64_vpbroadcastd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

8791

    let v2 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpbroadcastd, arg0);

8792

    // Rule at src/isa/x64/inst.isle line 4570.

8793

    return v2;

8794

8795

8796

// Generated as internal constructor for term x64_vbroadcastss.

8797

pub fn constructor_x64_vbroadcastss<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {

8798

    let v2 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vbroadcastss, arg0);

8799

    // Rule at src/isa/x64/inst.isle line 4575.

8800

    return v2;

8801

8802

8803

// Generated as internal constructor for term jmp_known.

8804

pub fn constructor_jmp_known<C: Context>(ctx: &mut C, arg0: MachLabel) -> SideEffectNoResult {

8805

    let v1 = MInst::JmpKnown { dst: arg0 };

8806

    let v2 = SideEffectNoResult::Inst { inst: v1 };

8807

    // Rule at src/isa/x64/inst.isle line 4582.

8808

    return v2;

8809

8810

8811

// Generated as internal constructor for term jmp_if.

8812

pub fn constructor_jmp_if<C: Context>(ctx: &mut C, arg0: &CC, arg1: MachLabel) -> ConsumesFlags {

8813

    let v2 = MInst::JmpIf {

8814

        cc: arg0.clone(),

8815

        taken: arg1,

8816

};

8817

    let v3 = ConsumesFlags::ConsumesFlagsSideEffect { inst: v2 };

8818

    // Rule at src/isa/x64/inst.isle line 4586.

8819

    return v3;

8820

8821

8822

// Generated as internal constructor for term jmp_cond.

8823

pub fn constructor_jmp_cond<C: Context>(

8824

    ctx: &mut C,

8825

    arg0: &CC,

8826

    arg1: MachLabel,

8827

    arg2: MachLabel,

8828

) -> ConsumesFlags {

8829

    let v3 = MInst::JmpCond {

8830

        cc: arg0.clone(),

8831

        taken: arg1,

8832

        not_taken: arg2,

8833

};

8834

    let v4 = ConsumesFlags::ConsumesFlagsSideEffect { inst: v3 };

8835

    // Rule at src/isa/x64/inst.isle line 4591.

8836

    return v4;

8837

8838

8839

// Generated as internal constructor for term jmp_cond_icmp.

8840

pub fn constructor_jmp_cond_icmp<C: Context>(

8841

    ctx: &mut C,

8842

    arg0: &IcmpCondResult,

8843

    arg1: MachLabel,

8844

    arg2: MachLabel,

8845

) -> SideEffectNoResult {

8846

    if let &IcmpCondResult::Condition {

8847

        producer: ref v1,

8848

        cc: ref v2,

8849

    } = arg0

8850

8851

        let v5 = &constructor_jmp_cond(ctx, v2, arg1, arg2);

8852

        let v6 = &constructor_with_flags_side_effect(ctx, v1, v5);

8853

        // Rule at src/isa/x64/inst.isle line 4596.

8854

        return v6.clone();

8855

8856

    unreachable!(

8857

        "no rule matched for term {} at {}; should it be partial?",

8858

        "jmp_cond_icmp", "src/isa/x64/inst.isle line 4595"

8859

8860

8861

8862

// Generated as internal constructor for term jmp_cond_fcmp.

8863

pub fn constructor_jmp_cond_fcmp<C: Context>(

8864

    ctx: &mut C,

8865

    arg0: &FcmpCondResult,

8866

    arg1: MachLabel,

8867

    arg2: MachLabel,

8868

) -> SideEffectNoResult {

8869

    match arg0 {

8870

        &FcmpCondResult::Condition {

8871

            producer: ref v1,

8872

            cc: ref v2,

8873

        } => {

8874

            let v5 = &constructor_jmp_cond(ctx, v2, arg1, arg2);

8875

            let v6 = &constructor_with_flags_side_effect(ctx, v1, v5);

8876

            // Rule at src/isa/x64/inst.isle line 4601.

8877

            return v6.clone();

8878

8879

        &FcmpCondResult::AndCondition {

8880

            producer: ref v7,

8881

            cc1: ref v8,

8882

            cc2: ref v9,

8883

        } => {

8884

            let v10 = &C::cc_invert(ctx, v8);

8885

            let v11 = &constructor_jmp_if(ctx, v10, arg2);

8886

            let v12 = &C::cc_invert(ctx, v9);

8887

            let v13 = &constructor_jmp_cond(ctx, v12, arg2, arg1);

8888

            let v14 = &constructor_consumes_flags_concat(ctx, v11, v13);

8889

            let v15 = &constructor_with_flags_side_effect(ctx, v7, v14);

8890

            // Rule at src/isa/x64/inst.isle line 4603.

8891

            return v15.clone();

8892

8893

        &FcmpCondResult::OrCondition {

8894

            producer: ref v16,

8895

            cc1: ref v17,

8896

            cc2: ref v18,

8897

        } => {

8898

            let v19 = &constructor_jmp_if(ctx, v17, arg1);

8899

            let v20 = &constructor_jmp_cond(ctx, v18, arg1, arg2);

8900

            let v21 = &constructor_consumes_flags_concat(ctx, v19, v20);

8901

            let v22 = &constructor_with_flags_side_effect(ctx, v16, v21);

8902

            // Rule at src/isa/x64/inst.isle line 4608.

8903

            return v22.clone();

8904

8905

        _ => {}

8906

8907

    unreachable!(

8908

        "no rule matched for term {} at {}; should it be partial?",

8909

        "jmp_cond_fcmp", "src/isa/x64/inst.isle line 4600"

8910

8911

8912

8913

// Generated as internal constructor for term jmp_table_seq.

8914

pub fn constructor_jmp_table_seq<C: Context>(

8915

    ctx: &mut C,

8916

    arg0: Type,

8917

    arg1: Gpr,

8918

    arg2: MachLabel,

8919

    arg3: &BoxVecMachLabel,

8920

) -> SideEffectNoResult {

8921

    let v4 = C::temp_writable_gpr(ctx);

8922

    let v5 = C::temp_writable_gpr(ctx);

8923

    let v6 = C::gpr_to_reg(ctx, arg1);

8924

    let v7 = C::writable_gpr_to_reg(ctx, v4);

8925

    let v8 = C::writable_gpr_to_reg(ctx, v5);

8926

    let v9 = MInst::JmpTableSeq {

8927

        idx: v6,

8928

        tmp1: v7,

8929

        tmp2: v8,

8930

        default_target: arg2,

8931

        targets: arg3.clone(),

8932

};

8933

    let v10 = SideEffectNoResult::Inst { inst: v9 };

8934

    // Rule at src/isa/x64/inst.isle line 4628.

8935

    return v10;

8936

8937

8938

// Generated as internal constructor for term icmp_cond_result.

8939

pub fn constructor_icmp_cond_result<C: Context>(

8940

    ctx: &mut C,

8941

    arg0: &ProducesFlags,

8942

    arg1: &CC,

8943

) -> IcmpCondResult {

8944

    let v2 = IcmpCondResult::Condition {

8945

        producer: arg0.clone(),

8946

        cc: arg1.clone(),

8947

};

8948

    // Rule at src/isa/x64/inst.isle line 4647.

8949

    return v2;

8950

8951

8952

// Generated as internal constructor for term invert_icmp_cond_result.

8953

pub fn constructor_invert_icmp_cond_result<C: Context>(

8954

    ctx: &mut C,

8955

    arg0: &IcmpCondResult,

8956

) -> IcmpCondResult {

8957

    if let &IcmpCondResult::Condition {

8958

        producer: ref v1,

8959

        cc: ref v2,

8960

    } = arg0

8961

8962

        let v3 = &C::cc_invert(ctx, v2);

8963

        let v4 = &constructor_icmp_cond_result(ctx, v1, v3);

8964

        // Rule at src/isa/x64/inst.isle line 4650.

8965

        return v4.clone();

8966

8967

    unreachable!(

8968

        "no rule matched for term {} at {}; should it be partial?",

8969

        "invert_icmp_cond_result", "src/isa/x64/inst.isle line 4649"

8970

8971

8972

8973

// Generated as internal constructor for term lower_icmp_bool.

8974

pub fn constructor_lower_icmp_bool<C: Context>(ctx: &mut C, arg0: &IcmpCondResult) -> ValueRegs {

8975

    if let &IcmpCondResult::Condition {

8976

        producer: ref v1,

8977

        cc: ref v2,

8978

    } = arg0

8979

8980

        let v3 = &constructor_x64_setcc(ctx, v2);

8981

        let v4 = constructor_with_flags(ctx, v1, v3);

8982

        // Rule at src/isa/x64/inst.isle line 4655.

8983

        return v4;

8984

8985

    unreachable!(

8986

        "no rule matched for term {} at {}; should it be partial?",

8987

        "lower_icmp_bool", "src/isa/x64/inst.isle line 4654"

8988

8989

8990

8991

// Generated as internal constructor for term select_icmp.

8992

pub fn constructor_select_icmp<C: Context>(

8993

    ctx: &mut C,

8994

    arg0: &IcmpCondResult,

8995

    arg1: Value,

8996

    arg2: Value,

8997

) -> ValueRegs {

8998

    if let &IcmpCondResult::Condition {

8999

        producer: ref v1,

9000

        cc: ref v2,

9001

    } = arg0

9002

9003

        let v4 = C::value_type(ctx, arg1);

9004

        let v5 = &C::type_register_class(ctx, v4);

9005

        if let Some(v6) = v5 {

9006

            if let &RegisterClass::Gpr {

9007

                single_register: v7,

9008

            } = v6

9009

9010

                if v7 == true {

9011

                    let v9 = constructor_put_in_gpr(ctx, arg1);

9012

                    let v10 = &C::gpr_to_gpr_mem(ctx, v9);

9013

                    let v11 = constructor_put_in_gpr(ctx, arg2);

9014

                    let v12 = &constructor_cmove(ctx, v4, v2, v10, v11);

9015

                    let v13 = constructor_with_flags(ctx, v1, v12);

9016

                    // Rule at src/isa/x64/inst.isle line 4664.

9017

                    return v13;

9018

9019

9020

9021

        let v14 = &constructor_cmove_from_values(ctx, v4, v2, arg1, arg2);

9022

        let v15 = constructor_with_flags(ctx, v1, v14);

9023

        // Rule at src/isa/x64/inst.isle line 4668.

9024

        return v15;

9025

9026

    unreachable!(

9027

        "no rule matched for term {} at {}; should it be partial?",

9028

        "select_icmp", "src/isa/x64/inst.isle line 4659"

9029

9030

9031

9032

// Generated as internal constructor for term emit_cmp.

9033

pub fn constructor_emit_cmp<C: Context>(

9034

    ctx: &mut C,

9035

    arg0: &IntCC,

9036

    arg1: Value,

9037

    arg2: Value,

9038

) -> IcmpCondResult {

9039

    let v2 = C::value_type(ctx, arg1);

9040

    if v2 == I128 {

9041

        match arg0 {

9042

            &IntCC::Equal => {

9043

                let v44 = C::put_in_regs(ctx, arg1);

9044

                let v46 = constructor_value_regs_get_gpr(ctx, v44, 0x0);

9045

                let v47 = C::put_in_regs(ctx, arg1);

9046

                let v49 = constructor_value_regs_get_gpr(ctx, v47, 0x1);

9047

                let v50 = C::put_in_regs(ctx, arg2);

9048

                let v51 = constructor_value_regs_get_gpr(ctx, v50, 0x0);

9049

                let v52 = C::put_in_regs(ctx, arg2);

9050

                let v53 = constructor_value_regs_get_gpr(ctx, v52, 0x1);

9051

                let v55 = &C::gpr_to_gpr_mem_imm(ctx, v51);

9052

                let v56 = &constructor_x64_cmp(ctx, &OperandSize::Size64, v55, v46);

9053

                let v58 = &constructor_x64_setcc(ctx, &CC::Z);

9054

                let v59 = constructor_with_flags_reg(ctx, v56, v58);

9055

                let v60 = &C::gpr_to_gpr_mem_imm(ctx, v53);

9056

                let v61 = &constructor_x64_cmp(ctx, &OperandSize::Size64, v60, v49);

9057

                let v62 = &constructor_x64_setcc(ctx, &CC::Z);

9058

                let v63 = constructor_with_flags_reg(ctx, v61, v62);

9059

                let v65 = C::gpr_new(ctx, v59);

9060

                let v66 = &constructor_reg_to_gpr_mem_imm(ctx, v63);

9061

                let v67 = constructor_x64_and(ctx, I64, v65, v66);

9062

                let v68 = C::gpr_to_reg(ctx, v67);

9063

                let v70 = RegMemImm::Imm { simm32: 0x1 };

9064

                let v71 = &C::gpr_mem_imm_new(ctx, &v70);

9065

                let v72 = C::gpr_new(ctx, v68);

9066

                let v73 = &constructor_x64_test(ctx, &OperandSize::Size64, v71, v72);

9067

                let v75 = &constructor_icmp_cond_result(ctx, v73, &CC::NZ);

9068

                // Rule at src/isa/x64/inst.isle line 4700.

9069

                return v75.clone();

9070

9071

            &IntCC::NotEqual => {

9072

                let v44 = C::put_in_regs(ctx, arg1);

9073

                let v46 = constructor_value_regs_get_gpr(ctx, v44, 0x0);

9074

                let v47 = C::put_in_regs(ctx, arg1);

9075

                let v49 = constructor_value_regs_get_gpr(ctx, v47, 0x1);

9076

                let v50 = C::put_in_regs(ctx, arg2);

9077

                let v51 = constructor_value_regs_get_gpr(ctx, v50, 0x0);

9078

                let v52 = C::put_in_regs(ctx, arg2);

9079

                let v53 = constructor_value_regs_get_gpr(ctx, v52, 0x1);

9080

                let v55 = &C::gpr_to_gpr_mem_imm(ctx, v51);

9081

                let v56 = &constructor_x64_cmp(ctx, &OperandSize::Size64, v55, v46);

9082

                let v76 = &constructor_x64_setcc(ctx, &CC::NZ);

9083

                let v77 = constructor_with_flags_reg(ctx, v56, v76);

9084

                let v60 = &C::gpr_to_gpr_mem_imm(ctx, v53);

9085

                let v61 = &constructor_x64_cmp(ctx, &OperandSize::Size64, v60, v49);

9086

                let v78 = &constructor_x64_setcc(ctx, &CC::NZ);

9087

                let v79 = constructor_with_flags_reg(ctx, v61, v78);

9088

                let v80 = C::gpr_new(ctx, v77);

9089

                let v81 = &constructor_reg_to_gpr_mem_imm(ctx, v79);

9090

                let v82 = constructor_x64_or(ctx, I64, v80, v81);

9091

                let v83 = C::gpr_to_reg(ctx, v82);

9092

                let v70 = RegMemImm::Imm { simm32: 0x1 };

9093

                let v71 = &C::gpr_mem_imm_new(ctx, &v70);

9094

                let v84 = C::gpr_new(ctx, v83);

9095

                let v85 = &constructor_x64_test(ctx, &OperandSize::Size64, v71, v84);

9096

                let v86 = &constructor_icmp_cond_result(ctx, v85, &CC::NZ);

9097

                // Rule at src/isa/x64/inst.isle line 4721.

9098

                return v86.clone();

9099

9100

            _ => {}

9101

9102

        let v44 = C::put_in_regs(ctx, arg1);

9103

        let v46 = constructor_value_regs_get_gpr(ctx, v44, 0x0);

9104

        let v47 = C::put_in_regs(ctx, arg1);

9105

        let v49 = constructor_value_regs_get_gpr(ctx, v47, 0x1);

9106

        let v50 = C::put_in_regs(ctx, arg2);

9107

        let v51 = constructor_value_regs_get_gpr(ctx, v50, 0x0);

9108

        let v52 = C::put_in_regs(ctx, arg2);

9109

        let v53 = constructor_value_regs_get_gpr(ctx, v52, 0x1);

9110

        let v87 = &C::gpr_to_gpr_mem_imm(ctx, v53);

9111

        let v88 = &constructor_x64_cmp(ctx, &OperandSize::Size64, v87, v49);

9112

        let v89 = &C::intcc_without_eq(ctx, arg0);

9113

        let v90 = &C::intcc_to_cc(ctx, v89);

9114

        let v91 = &constructor_x64_setcc(ctx, v90);

9115

        let v92 = &constructor_x64_setcc(ctx, &CC::Z);

9116

        let v93 = &constructor_consumes_flags_concat(ctx, v91, v92);

9117

        let v94 = constructor_with_flags(ctx, v88, v93);

9118

        let v95 = C::value_regs_get(ctx, v94, 0x0);

9119

        let v96 = C::value_regs_get(ctx, v94, 0x1);

9120

        let v97 = &C::gpr_to_gpr_mem_imm(ctx, v51);

9121

        let v98 = &constructor_x64_cmp(ctx, &OperandSize::Size64, v97, v46);

9122

        let v99 = &C::intcc_unsigned(ctx, arg0);

9123

        let v100 = &C::intcc_to_cc(ctx, v99);

9124

        let v101 = &constructor_x64_setcc(ctx, v100);

9125

        let v102 = constructor_with_flags_reg(ctx, v98, v101);

9126

        let v103 = C::gpr_new(ctx, v96);

9127

        let v104 = &constructor_reg_to_gpr_mem_imm(ctx, v102);

9128

        let v105 = constructor_x64_and(ctx, I64, v103, v104);

9129

        let v106 = C::gpr_to_reg(ctx, v105);

9130

        let v107 = C::gpr_new(ctx, v95);

9131

        let v108 = &constructor_reg_to_gpr_mem_imm(ctx, v106);

9132

        let v109 = constructor_x64_or(ctx, I64, v107, v108);

9133

        let v110 = C::gpr_to_reg(ctx, v109);

9134

        let v70 = RegMemImm::Imm { simm32: 0x1 };

9135

        let v111 = &C::gpr_mem_imm_new(ctx, &v70);

9136

        let v112 = C::gpr_new(ctx, v110);

9137

        let v113 = &constructor_x64_test(ctx, &OperandSize::Size64, v111, v112);

9138

        let v114 = &constructor_icmp_cond_result(ctx, v113, &CC::NZ);

9139

        // Rule at src/isa/x64/inst.isle line 4736.

9140

        return v114.clone();

9141

9142

    let v29 = C::def_inst(ctx, arg1);

9143

    if let Some(v30) = v29 {

9144

        let v31 = &C::inst_data(ctx, v30);

9145

        if let &InstructionData::UnaryImm {

9146

            opcode: ref v32,

9147

            imm: v33,

9148

        } = v31

9149

9150

            if let &Opcode::Iconst = v32 {

9151

                let v34 = C::u64_from_imm64(ctx, v33);

9152

                if v34 == 0x0 {

9153

                    let v35 = C::value_type(ctx, arg2);

9154

                    let v36 = &C::raw_operand_size_of_type(ctx, v35);

9155

                    let v37 = C::put_in_reg(ctx, arg2);

9156

                    let v38 = C::gpr_new(ctx, v37);

9157

                    let v39 = &C::gpr_to_gpr_mem_imm(ctx, v38);

9158

                    let v40 = &constructor_x64_test(ctx, v36, v39, v38);

9159

                    let v41 = &C::intcc_swap_args(ctx, arg0);

9160

                    let v42 = &C::intcc_to_cc(ctx, v41);

9161

                    let v43 = &constructor_icmp_cond_result(ctx, v40, v42);

9162

                    // Rule at src/isa/x64/inst.isle line 4693.

9163

                    return v43.clone();

9164

9165

9166

9167

9168

    let v17 = C::def_inst(ctx, arg2);

9169

    if let Some(v18) = v17 {

9170

        let v19 = &C::inst_data(ctx, v18);

9171

        if let &InstructionData::UnaryImm {

9172

            opcode: ref v20,

9173

            imm: v21,

9174

        } = v19

9175

9176

            if let &Opcode::Iconst = v20 {

9177

                let v22 = C::u64_from_imm64(ctx, v21);

9178

                if v22 == 0x0 {

9179

                    let v4 = &C::raw_operand_size_of_type(ctx, v2);

9180

                    let v23 = C::put_in_reg(ctx, arg1);

9181

                    let v24 = C::gpr_new(ctx, v23);

9182

                    let v25 = &C::gpr_to_gpr_mem_imm(ctx, v24);

9183

                    let v26 = &constructor_x64_test(ctx, v4, v25, v24);

9184

                    let v27 = &C::intcc_to_cc(ctx, arg0);

9185

                    let v28 = &constructor_icmp_cond_result(ctx, v26, v27);

9186

                    // Rule at src/isa/x64/inst.isle line 4688.

9187

                    return v28.clone();

9188

9189

9190

9191

9192

    let v10 = &C::simm32_from_value(ctx, arg1);

9193

    if let Some(v11) = v10 {

9194

        let v4 = &C::raw_operand_size_of_type(ctx, v2);

9195

        let v12 = constructor_put_in_gpr(ctx, arg2);

9196

        let v13 = &constructor_x64_cmp(ctx, v4, v11, v12);

9197

        let v14 = &C::intcc_swap_args(ctx, arg0);

9198

        let v15 = &C::intcc_to_cc(ctx, v14);

9199

        let v16 = &constructor_icmp_cond_result(ctx, v13, v15);

9200

        // Rule at src/isa/x64/inst.isle line 4683.

9201

        return v16.clone();

9202

9203

    let v4 = &C::raw_operand_size_of_type(ctx, v2);

9204

    let v5 = &constructor_put_in_gpr_mem_imm(ctx, arg2);

9205

    let v6 = constructor_put_in_gpr(ctx, arg1);

9206

    let v7 = &constructor_x64_cmp(ctx, v4, v5, v6);

9207

    let v8 = &C::intcc_to_cc(ctx, arg0);

9208

    let v9 = &constructor_icmp_cond_result(ctx, v7, v8);

9209

    // Rule at src/isa/x64/inst.isle line 4676.

9210

    return v9.clone();

9211

9212

9213

// Generated as internal constructor for term lower_fcmp_bool.

9214

pub fn constructor_lower_fcmp_bool<C: Context>(ctx: &mut C, arg0: &FcmpCondResult) -> ValueRegs {

9215

    match arg0 {

9216

        &FcmpCondResult::Condition {

9217

            producer: ref v1,

9218

            cc: ref v2,

9219

        } => {

9220

            let v3 = &constructor_x64_setcc(ctx, v2);

9221

            let v4 = constructor_with_flags(ctx, v1, v3);

9222

            // Rule at src/isa/x64/inst.isle line 4771.

9223

            return v4;

9224

9225

        &FcmpCondResult::AndCondition {

9226

            producer: ref v5,

9227

            cc1: ref v6,

9228

            cc2: ref v7,

9229

        } => {

9230

            let v8 = &constructor_x64_setcc(ctx, v6);

9231

            let v9 = &constructor_x64_setcc(ctx, v7);

9232

            let v10 = &constructor_consumes_flags_concat(ctx, v8, v9);

9233

            let v11 = constructor_with_flags(ctx, v5, v10);

9234

            let v13 = constructor_value_regs_get_gpr(ctx, v11, 0x0);

9235

            let v15 = constructor_value_regs_get_gpr(ctx, v11, 0x1);

9236

            let v17 = &C::gpr_to_gpr_mem_imm(ctx, v15);

9237

            let v18 = constructor_x64_and(ctx, I8, v13, v17);

9238

            let v19 = C::gpr_to_reg(ctx, v18);

9239

            let v20 = C::value_reg(ctx, v19);

9240

            // Rule at src/isa/x64/inst.isle line 4774.

9241

            return v20;

9242

9243

        &FcmpCondResult::OrCondition {

9244

            producer: ref v21,

9245

            cc1: ref v22,

9246

            cc2: ref v23,

9247

        } => {

9248

            let v24 = &constructor_x64_setcc(ctx, v22);

9249

            let v25 = &constructor_x64_setcc(ctx, v23);

9250

            let v26 = &constructor_consumes_flags_concat(ctx, v24, v25);

9251

            let v27 = constructor_with_flags(ctx, v21, v26);

9252

            let v28 = constructor_value_regs_get_gpr(ctx, v27, 0x0);

9253

            let v29 = constructor_value_regs_get_gpr(ctx, v27, 0x1);

9254

            let v30 = &C::gpr_to_gpr_mem_imm(ctx, v29);

9255

            let v31 = constructor_x64_or(ctx, I8, v28, v30);

9256

            let v32 = C::gpr_to_reg(ctx, v31);

9257

            let v33 = C::value_reg(ctx, v32);

9258

            // Rule at src/isa/x64/inst.isle line 4783.

9259

            return v33;

9260

9261

        _ => {}

9262

9263

    unreachable!(

9264

        "no rule matched for term {} at {}; should it be partial?",

9265

        "lower_fcmp_bool", "src/isa/x64/inst.isle line 4769"

9266

9267

9268

9269

// Generated as internal constructor for term emit_fcmp.

9270

pub fn constructor_emit_fcmp<C: Context>(

9271

    ctx: &mut C,

9272

    arg0: &FloatCC,

9273

    arg1: Value,

9274

    arg2: Value,

9275

) -> FcmpCondResult {

9276

    match arg0 {

9277

        &FloatCC::Equal => {

9278

            let v2 = C::value_type(ctx, arg1);

9279

            let v3 = C::ty_scalar_float(ctx, v2);

9280

            if let Some(v4) = v3 {

9281

                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);

9282

                let v9 = FcmpCondResult::AndCondition {

9283

                    producer: v6.clone(),

9284

                    cc1: CC::NP,

9285

                    cc2: CC::Z,

9286

};

9287

                // Rule at src/isa/x64/inst.isle line 4810.

9288

                return v9;

9289

9290

9291

        &FloatCC::GreaterThan => {

9292

            let v2 = C::value_type(ctx, arg1);

9293

            let v3 = C::ty_scalar_float(ctx, v2);

9294

            if let Some(v4) = v3 {

9295

                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);

9296

                let v18 = FcmpCondResult::Condition {

9297

                    producer: v6.clone(),

9298

                    cc: CC::NBE,

9299

};

9300

                // Rule at src/isa/x64/inst.isle line 4826.

9301

                return v18;

9302

9303

9304

        &FloatCC::GreaterThanOrEqual => {

9305

            let v2 = C::value_type(ctx, arg1);

9306

            let v3 = C::ty_scalar_float(ctx, v2);

9307

            if let Some(v4) = v3 {

9308

                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);

9309

                let v20 = FcmpCondResult::Condition {

9310

                    producer: v6.clone(),

9311

                    cc: CC::NB,

9312

};

9313

                // Rule at src/isa/x64/inst.isle line 4828.

9314

                return v20;

9315

9316

9317

        &FloatCC::LessThan => {

9318

            let v2 = C::value_type(ctx, arg1);

9319

            let v3 = C::ty_scalar_float(ctx, v2);

9320

            if let Some(v4) = v3 {

9321

                let v25 = &constructor_x64_ucomis(ctx, arg1, arg2);

9322

                let v26 = FcmpCondResult::Condition {

9323

                    producer: v25.clone(),

9324

                    cc: CC::NBE,

9325

};

9326

                // Rule at src/isa/x64/inst.isle line 4838.

9327

                return v26;

9328

9329

9330

        &FloatCC::LessThanOrEqual => {

9331

            let v2 = C::value_type(ctx, arg1);

9332

            let v3 = C::ty_scalar_float(ctx, v2);

9333

            if let Some(v4) = v3 {

9334

                let v25 = &constructor_x64_ucomis(ctx, arg1, arg2);

9335

                let v27 = FcmpCondResult::Condition {

9336

                    producer: v25.clone(),

9337

                    cc: CC::NB,

9338

};

9339

                // Rule at src/isa/x64/inst.isle line 4841.

9340

                return v27;

9341

9342

9343

        &FloatCC::NotEqual => {

9344

            let v2 = C::value_type(ctx, arg1);

9345

            let v3 = C::ty_scalar_float(ctx, v2);

9346

            if let Some(v4) = v3 {

9347

                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);

9348

                let v12 = FcmpCondResult::OrCondition {

9349

                    producer: v6.clone(),

9350

                    cc1: CC::P,

9351

                    cc2: CC::NZ,

9352

};

9353

                // Rule at src/isa/x64/inst.isle line 4813.

9354

                return v12;

9355

9356

9357

        &FloatCC::Ordered => {

9358

            let v2 = C::value_type(ctx, arg1);

9359

            let v3 = C::ty_scalar_float(ctx, v2);

9360

            if let Some(v4) = v3 {

9361

                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);

9362

                let v13 = FcmpCondResult::Condition {

9363

                    producer: v6.clone(),

9364

                    cc: CC::NP,

9365

};

9366

                // Rule at src/isa/x64/inst.isle line 4818.

9367

                return v13;

9368

9369

9370

        &FloatCC::OrderedNotEqual => {

9371

            let v2 = C::value_type(ctx, arg1);

9372

            let v3 = C::ty_scalar_float(ctx, v2);

9373

            if let Some(v4) = v3 {

9374

                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);

9375

                let v15 = FcmpCondResult::Condition {

9376

                    producer: v6.clone(),

9377

                    cc: CC::NZ,

9378

};

9379

                // Rule at src/isa/x64/inst.isle line 4822.

9380

                return v15;

9381

9382

9383

        &FloatCC::Unordered => {

9384

            let v2 = C::value_type(ctx, arg1);

9385

            let v3 = C::ty_scalar_float(ctx, v2);

9386

            if let Some(v4) = v3 {

9387

                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);

9388

                let v14 = FcmpCondResult::Condition {

9389

                    producer: v6.clone(),

9390

                    cc: CC::P,

9391

};

9392

                // Rule at src/isa/x64/inst.isle line 4820.

9393

                return v14;

9394

9395

9396

        &FloatCC::UnorderedOrEqual => {

9397

            let v2 = C::value_type(ctx, arg1);

9398

            let v3 = C::ty_scalar_float(ctx, v2);

9399

            if let Some(v4) = v3 {

9400

                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);

9401

                let v16 = FcmpCondResult::Condition {

9402

                    producer: v6.clone(),

9403

                    cc: CC::Z,

9404

};

9405

                // Rule at src/isa/x64/inst.isle line 4824.

9406

                return v16;

9407

9408

9409

        &FloatCC::UnorderedOrGreaterThan => {

9410

            let v2 = C::value_type(ctx, arg1);

9411

            let v3 = C::ty_scalar_float(ctx, v2);

9412

            if let Some(v4) = v3 {

9413

                let v25 = &constructor_x64_ucomis(ctx, arg1, arg2);

9414

                let v28 = FcmpCondResult::Condition {

9415

                    producer: v25.clone(),

9416

                    cc: CC::B,

9417

};

9418

                // Rule at src/isa/x64/inst.isle line 4844.

9419

                return v28;

9420

9421

9422

        &FloatCC::UnorderedOrGreaterThanOrEqual => {

9423

            let v2 = C::value_type(ctx, arg1);

9424

            let v3 = C::ty_scalar_float(ctx, v2);

9425

            if let Some(v4) = v3 {

9426

                let v25 = &constructor_x64_ucomis(ctx, arg1, arg2);

9427

                let v29 = FcmpCondResult::Condition {

9428

                    producer: v25.clone(),

9429

                    cc: CC::BE,

9430

};

9431

                // Rule at src/isa/x64/inst.isle line 4847.

9432

                return v29;

9433

9434

9435

        &FloatCC::UnorderedOrLessThan => {

9436

            let v2 = C::value_type(ctx, arg1);

9437

            let v3 = C::ty_scalar_float(ctx, v2);

9438

            if let Some(v4) = v3 {

9439

                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);

9440

                let v22 = FcmpCondResult::Condition {

9441

                    producer: v6.clone(),

9442

                    cc: CC::B,

9443

};

9444

                // Rule at src/isa/x64/inst.isle line 4830.

9445

                return v22;

9446

9447

9448

        &FloatCC::UnorderedOrLessThanOrEqual => {

9449

            let v2 = C::value_type(ctx, arg1);

9450

            let v3 = C::ty_scalar_float(ctx, v2);

9451

            if let Some(v4) = v3 {

9452

                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);

9453

                let v24 = FcmpCondResult::Condition {

9454

                    producer: v6.clone(),

9455

                    cc: CC::BE,

9456

};

9457

                // Rule at src/isa/x64/inst.isle line 4832.

9458

                return v24;

9459

9460

9461

        _ => {}

9462

9463

    unreachable!(

9464

        "no rule matched for term {} at {}; should it be partial?",

9465

        "emit_fcmp", "src/isa/x64/inst.isle line 4808"

9466

9467

9468

9469

// Generated as internal constructor for term x64_mfence.

9470

pub fn constructor_x64_mfence<C: Context>(ctx: &mut C) -> SideEffectNoResult {

9471

    let v1 = MInst::Fence {

9472

        kind: FenceKind::MFence,

9473

};

9474

    let v2 = SideEffectNoResult::Inst { inst: v1 };

9475

    // Rule at src/isa/x64/inst.isle line 4860.

9476

    return v2;

9477

9478

9479

// Generated as internal constructor for term x64_cmpxchg.

9480

pub fn constructor_x64_cmpxchg<C: Context>(

9481

    ctx: &mut C,

9482

    arg0: Type,

9483

    arg1: Gpr,

9484

    arg2: Gpr,

9485

    arg3: &SyntheticAmode,

9486

) -> Gpr {

9487

    let v4 = C::temp_writable_gpr(ctx);

9488

    let v5 = C::gpr_to_reg(ctx, arg2);

9489

    let v6 = C::gpr_to_reg(ctx, arg1);

9490

    let v7 = C::writable_gpr_to_reg(ctx, v4);

9491

    let v8 = MInst::LockCmpxchg {

9492

        ty: arg0,

9493

        replacement: v5,

9494

        expected: v6,

9495

        mem: arg3.clone(),

9496

        dst_old: v7,

9497

};

9498

    let v9 = C::emit(ctx, &v8);

9499

    let v10 = C::writable_gpr_to_gpr(ctx, v4);

9500

    // Rule at src/isa/x64/inst.isle line 4864.

9501

    return v10;

9502

9503

9504

// Generated as internal constructor for term x64_atomic_rmw_seq.

9505

pub fn constructor_x64_atomic_rmw_seq<C: Context>(

9506

    ctx: &mut C,

9507

    arg0: Type,

9508

    arg1: &MachAtomicRmwOp,

9509

    arg2: &SyntheticAmode,

9510

    arg3: Gpr,

9511

) -> Gpr {

9512

    let v4 = C::temp_writable_gpr(ctx);

9513

    let v5 = C::temp_writable_gpr(ctx);

9514

    let v6 = C::gpr_to_reg(ctx, arg3);

9515

    let v7 = C::writable_gpr_to_reg(ctx, v5);

9516

    let v8 = C::writable_gpr_to_reg(ctx, v4);

9517

    let v9 = MInst::AtomicRmwSeq {

9518

        ty: arg0,

9519

        op: arg1.clone(),

9520

        mem: arg2.clone(),

9521

        operand: v6,

9522

        temp: v7,

9523

        dst_old: v8,

9524

};

9525

    let v10 = C::emit(ctx, &v9);

9526

    let v11 = C::writable_gpr_to_gpr(ctx, v4);

9527

    // Rule at src/isa/x64/inst.isle line 4870.

9528

    return v11;

9529

9530

9531

// Generated as internal constructor for term bitcast_xmm_to_gpr.

9532

pub fn constructor_bitcast_xmm_to_gpr<C: Context>(ctx: &mut C, arg0: Type, arg1: Xmm) -> Gpr {

9533

    match arg0 {

9534

        F32 => {

9535

            let v2 = constructor_x64_movd_to_gpr(ctx, arg1);

9536

            // Rule at src/isa/x64/inst.isle line 4885.

9537

            return v2;

9538

9539

        F64 => {

9540

            let v3 = constructor_x64_movq_to_gpr(ctx, arg1);

9541

            // Rule at src/isa/x64/inst.isle line 4887.

9542

            return v3;

9543

9544

        _ => {}

9545

9546

    unreachable!(

9547

        "no rule matched for term {} at {}; should it be partial?",

9548

        "bitcast_xmm_to_gpr", "src/isa/x64/inst.isle line 4884"

9549

9550

9551

9552

// Generated as internal constructor for term bitcast_gpr_to_xmm.

9553

pub fn constructor_bitcast_gpr_to_xmm<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Xmm {

9554

    match arg0 {

9555

        I32 => {

9556

            let v2 = &C::gpr_to_gpr_mem(ctx, arg1);

9557

            let v3 = constructor_x64_movd_to_xmm(ctx, v2);

9558

            // Rule at src/isa/x64/inst.isle line 4891.

9559

            return v3;

9560

9561

        I64 => {

9562

            let v2 = &C::gpr_to_gpr_mem(ctx, arg1);

9563

            let v4 = constructor_x64_movq_to_xmm(ctx, v2);

9564

            // Rule at src/isa/x64/inst.isle line 4893.

9565

            return v4;

9566

9567

        _ => {}

9568

9569

    unreachable!(

9570

        "no rule matched for term {} at {}; should it be partial?",

9571

        "bitcast_gpr_to_xmm", "src/isa/x64/inst.isle line 4890"

9572

9573

9574

9575

// Generated as internal constructor for term stack_addr_impl.

9576

pub fn constructor_stack_addr_impl<C: Context>(

9577

    ctx: &mut C,

9578

    arg0: StackSlot,

9579

    arg1: Offset32,

9580

) -> Gpr {

9581

    let v2 = C::temp_writable_gpr(ctx);

9582

    let v3 = C::writable_gpr_to_reg(ctx, v2);

9583

    let v4 = &C::abi_stackslot_addr(ctx, v3, arg0, arg1);

9584

    let v5 = C::emit(ctx, v4);

9585

    let v6 = C::writable_gpr_to_gpr(ctx, v2);

9586

    // Rule at src/isa/x64/inst.isle line 4899.

9587

    return v6;

9588

9589

9590

// Generated as internal constructor for term x64_checked_srem_seq.

9591

pub fn constructor_x64_checked_srem_seq<C: Context>(

9592

    ctx: &mut C,

9593

    arg0: &OperandSize,

9594

    arg1: Gpr,

9595

    arg2: Gpr,

9596

    arg3: Gpr,

9597

) -> ValueRegs {

9598

    let v4 = C::temp_writable_gpr(ctx);

9599

    let v5 = C::temp_writable_gpr(ctx);

9600

    let v6 = MInst::CheckedSRemSeq {

9601

        size: arg0.clone(),

9602

        dividend_lo: arg1,

9603

        dividend_hi: arg2,

9604

        divisor: arg3,

9605

        dst_quotient: v4,

9606

        dst_remainder: v5,

9607

};

9608

    let v7 = C::emit(ctx, &v6);

9609

    let v8 = constructor_writable_gpr_to_r_reg(ctx, v4);

9610

    let v9 = constructor_writable_gpr_to_r_reg(ctx, v5);

9611

    let v10 = C::value_regs(ctx, v8, v9);

9612

    // Rule at src/isa/x64/inst.isle line 4908.

9613

    return v10;

9614

9615

9616

// Generated as internal constructor for term x64_checked_srem_seq8.

9617

pub fn constructor_x64_checked_srem_seq8<C: Context>(ctx: &mut C, arg0: Gpr, arg1: Gpr) -> Gpr {

9618

    let v2 = C::temp_writable_gpr(ctx);

9619

    let v3 = MInst::CheckedSRemSeq8 {

9620

        dividend: arg0,

9621

        divisor: arg1,

9622

        dst: v2,

9623

};

9624

    let v4 = C::emit(ctx, &v3);

9625

    let v5 = C::writable_gpr_to_gpr(ctx, v2);

9626

    // Rule at src/isa/x64/inst.isle line 4915.

9627

    return v5;

9628

9629

9630

// Generated as internal constructor for term x64_div8.

9631

pub fn constructor_x64_div8<C: Context>(

9632

    ctx: &mut C,

9633

    arg0: Gpr,

9634

    arg1: &GprMem,

9635

    arg2: &DivSignedness,

9636

    arg3: &TrapCode,

9637

) -> Gpr {

9638

    let v4 = C::temp_writable_gpr(ctx);

9639

    let v5 = MInst::Div8 {

9640

        sign: arg2.clone(),

9641

        trap: arg3.clone(),

9642

        divisor: arg1.clone(),

9643

        dividend: arg0,

9644

        dst: v4,

9645

};

9646

    let v6 = C::emit(ctx, &v5);

9647

    let v7 = C::writable_gpr_to_gpr(ctx, v4);

9648

    // Rule at src/isa/x64/inst.isle line 4922.

9649

    return v7;

9650

9651

9652

// Generated as internal constructor for term x64_div.

9653

pub fn constructor_x64_div<C: Context>(

9654

    ctx: &mut C,

9655

    arg0: Gpr,

9656

    arg1: Gpr,

9657

    arg2: &GprMem,

9658

    arg3: &OperandSize,

9659

    arg4: &DivSignedness,

9660

    arg5: &TrapCode,

9661

) -> ValueRegs {

9662

    let v6 = C::temp_writable_gpr(ctx);

9663

    let v7 = C::temp_writable_gpr(ctx);

9664

    let v8 = MInst::Div {

9665

        size: arg3.clone(),

9666

        sign: arg4.clone(),

9667

        trap: arg5.clone(),

9668

        divisor: arg2.clone(),

9669

        dividend_lo: arg0,

9670

        dividend_hi: arg1,

9671

        dst_quotient: v6,

9672

        dst_remainder: v7,

9673

};

9674

    let v9 = C::emit(ctx, &v8);

9675

    let v10 = constructor_writable_gpr_to_r_reg(ctx, v6);

9676

    let v11 = constructor_writable_gpr_to_r_reg(ctx, v7);

9677

    let v12 = C::value_regs(ctx, v10, v11);

9678

    // Rule at src/isa/x64/inst.isle line 4932.

9679

    return v12;

9680

9681

9682

// Generated as internal constructor for term x64_div_quotient.

9683

pub fn constructor_x64_div_quotient<C: Context>(

9684

    ctx: &mut C,

9685

    arg0: Gpr,

9686

    arg1: Gpr,

9687

    arg2: &GprMem,

9688

    arg3: &OperandSize,

9689

    arg4: &DivSignedness,

9690

    arg5: &TrapCode,

9691

) -> ValueRegs {

9692

    let v6 = constructor_x64_div(ctx, arg0, arg1, arg2, arg3, arg4, arg5);

9693

    let v8 = C::value_regs_get(ctx, v6, 0x0);

9694

    let v9 = C::value_reg(ctx, v8);

9695

    // Rule at src/isa/x64/inst.isle line 4940.

9696

    return v9;

9697

9698

9699

// Generated as internal constructor for term x64_div_remainder.

9700

pub fn constructor_x64_div_remainder<C: Context>(

9701

    ctx: &mut C,

9702

    arg0: Gpr,

9703

    arg1: Gpr,

9704

    arg2: &GprMem,

9705

    arg3: &OperandSize,

9706

    arg4: &DivSignedness,

9707

    arg5: &TrapCode,

9708

) -> ValueRegs {

9709

    let v6 = constructor_x64_div(ctx, arg0, arg1, arg2, arg3, arg4, arg5);

9710

    let v8 = C::value_regs_get(ctx, v6, 0x1);

9711

    let v9 = C::value_reg(ctx, v8);

9712

    // Rule at src/isa/x64/inst.isle line 4945.

9713

    return v9;

9714

9715

9716

// Generated as internal constructor for term x64_sign_extend_data.

9717

pub fn constructor_x64_sign_extend_data<C: Context>(

9718

    ctx: &mut C,

9719

    arg0: Gpr,

9720

    arg1: &OperandSize,

9721

) -> Gpr {

9722

    let v2 = C::temp_writable_gpr(ctx);

9723

    let v3 = MInst::SignExtendData {

9724

        size: arg1.clone(),

9725

        src: arg0,

9726

        dst: v2,

9727

};

9728

    let v4 = C::emit(ctx, &v3);

9729

    let v5 = C::writable_gpr_to_gpr(ctx, v2);

9730

    // Rule at src/isa/x64/inst.isle line 4950.

9731

    return v5;

9732

9733

9734

// Generated as internal constructor for term read_pinned_gpr.

9735

pub fn constructor_read_pinned_gpr<C: Context>(ctx: &mut C) -> Gpr {

9736

    let v0 = C::preg_pinned(ctx);

9737

    let v1 = constructor_mov_from_preg(ctx, v0);

9738

    let v2 = C::gpr_new(ctx, v1);

9739

    // Rule at src/isa/x64/inst.isle line 4958.

9740

    return v2;

9741

9742

9743

// Generated as internal constructor for term write_pinned_gpr.

9744

pub fn constructor_write_pinned_gpr<C: Context>(ctx: &mut C, arg0: Gpr) -> SideEffectNoResult {

9745

    let v1 = C::preg_pinned(ctx);

9746

    let v2 = &constructor_mov_to_preg(ctx, v1, arg0);

9747

    // Rule at src/isa/x64/inst.isle line 4962.

9748

    return v2.clone();

9749

9750

9751

// Generated as internal constructor for term elf_tls_get_addr.

9752

pub fn constructor_elf_tls_get_addr<C: Context>(ctx: &mut C, arg0: ExternalName) -> Gpr {

9753

    let v1 = C::temp_writable_gpr(ctx);

9754

    let v2 = MInst::ElfTlsGetAddr {

9755

        symbol: arg0,

9756

        dst: v1,

9757

};

9758

    let v3 = C::emit(ctx, &v2);

9759

    let v4 = C::writable_gpr_to_gpr(ctx, v1);

9760

    // Rule at src/isa/x64/inst.isle line 5004.

9761

    return v4;

9762

9763

9764

// Generated as internal constructor for term macho_tls_get_addr.

9765

pub fn constructor_macho_tls_get_addr<C: Context>(ctx: &mut C, arg0: ExternalName) -> Gpr {

9766

    let v1 = C::temp_writable_gpr(ctx);

9767

    let v2 = MInst::MachOTlsGetAddr {

9768

        symbol: arg0,

9769

        dst: v1,

9770

};

9771

    let v3 = C::emit(ctx, &v2);

9772

    let v4 = C::writable_gpr_to_gpr(ctx, v1);

9773

    // Rule at src/isa/x64/inst.isle line 5011.

9774

    return v4;

9775

9776

9777

// Generated as internal constructor for term coff_tls_get_addr.

9778

pub fn constructor_coff_tls_get_addr<C: Context>(ctx: &mut C, arg0: ExternalName) -> Gpr {

9779

    let v1 = C::temp_writable_gpr(ctx);

9780

    let v2 = C::temp_writable_gpr(ctx);

9781

    let v3 = MInst::CoffTlsGetAddr {

9782

        symbol: arg0,

9783

        dst: v1,

9784

        tmp: v2,

9785

};

9786

    let v4 = C::emit(ctx, &v3);

9787

    let v5 = C::writable_gpr_to_gpr(ctx, v1);

9788

    // Rule at src/isa/x64/inst.isle line 5018.

9789

    return v5;

9790

9791

9792

// Generated as internal constructor for term reg_to_xmm_mem.

9793

pub fn constructor_reg_to_xmm_mem<C: Context>(ctx: &mut C, arg0: Reg) -> XmmMem {

9794

    let v1 = C::xmm_new(ctx, arg0);

9795

    let v2 = &C::xmm_to_xmm_mem(ctx, v1);

9796

    // Rule at src/isa/x64/inst.isle line 5105.

9797

    return v2.clone();

9798

9799

9800

// Generated as internal constructor for term xmm_to_reg_mem.

9801

pub fn constructor_xmm_to_reg_mem<C: Context>(ctx: &mut C, arg0: Reg) -> XmmMem {

9802

    let v1 = C::xmm_new(ctx, arg0);

9803

    let v2 = C::xmm_to_reg(ctx, v1);

9804

    let v3 = RegMem::Reg { reg: v2 };

9805

    let v4 = &C::reg_mem_to_xmm_mem(ctx, &v3);

9806

    // Rule at src/isa/x64/inst.isle line 5108.

9807

    return v4.clone();

9808

9809

9810

// Generated as internal constructor for term writable_gpr_to_r_reg.

9811

pub fn constructor_writable_gpr_to_r_reg<C: Context>(ctx: &mut C, arg0: WritableGpr) -> Reg {

9812

    let v1 = C::writable_gpr_to_reg(ctx, arg0);

9813

    let v2 = C::writable_reg_to_reg(ctx, v1);

9814

    // Rule at src/isa/x64/inst.isle line 5112.

9815

    return v2;

9816

9817

9818

// Generated as internal constructor for term writable_gpr_to_gpr_mem.

9819

pub fn constructor_writable_gpr_to_gpr_mem<C: Context>(ctx: &mut C, arg0: WritableGpr) -> GprMem {

9820

    let v1 = C::writable_gpr_to_gpr(ctx, arg0);

9821

    let v2 = &C::gpr_to_gpr_mem(ctx, v1);

9822

    // Rule at src/isa/x64/inst.isle line 5115.

9823

    return v2.clone();

9824

9825

9826

// Generated as internal constructor for term writable_gpr_to_value_regs.

9827

pub fn constructor_writable_gpr_to_value_regs<C: Context>(

9828

    ctx: &mut C,

9829

    arg0: WritableGpr,

9830

) -> ValueRegs {

9831

    let v1 = constructor_writable_gpr_to_r_reg(ctx, arg0);

9832

    let v2 = C::value_reg(ctx, v1);

9833

    // Rule at src/isa/x64/inst.isle line 5118.

9834

    return v2;

9835

9836

9837

// Generated as internal constructor for term writable_xmm_to_r_reg.

9838

pub fn constructor_writable_xmm_to_r_reg<C: Context>(ctx: &mut C, arg0: WritableXmm) -> Reg {

9839

    let v1 = C::writable_xmm_to_reg(ctx, arg0);

9840

    let v2 = C::writable_reg_to_reg(ctx, v1);

9841

    // Rule at src/isa/x64/inst.isle line 5121.

9842

    return v2;

9843

9844

9845

// Generated as internal constructor for term writable_xmm_to_xmm_mem.

9846

pub fn constructor_writable_xmm_to_xmm_mem<C: Context>(ctx: &mut C, arg0: WritableXmm) -> XmmMem {

9847

    let v1 = C::writable_xmm_to_xmm(ctx, arg0);

9848

    let v2 = &C::xmm_to_xmm_mem(ctx, v1);

9849

    // Rule at src/isa/x64/inst.isle line 5124.

9850

    return v2.clone();

9851

9852

9853

// Generated as internal constructor for term writable_xmm_to_value_regs.

9854

pub fn constructor_writable_xmm_to_value_regs<C: Context>(

9855

    ctx: &mut C,

9856

    arg0: WritableXmm,

9857

) -> ValueRegs {

9858

    let v1 = constructor_writable_xmm_to_r_reg(ctx, arg0);

9859

    let v2 = C::value_reg(ctx, v1);

9860

    // Rule at src/isa/x64/inst.isle line 5127.

9861

    return v2;

9862

9863

9864

// Generated as internal constructor for term synthetic_amode_to_gpr_mem.

9865

pub fn constructor_synthetic_amode_to_gpr_mem<C: Context>(

9866

    ctx: &mut C,

9867

    arg0: &SyntheticAmode,

9868

) -> GprMem {

9869

    let v1 = &C::synthetic_amode_to_reg_mem(ctx, arg0);

9870

    let v2 = &C::reg_mem_to_gpr_mem(ctx, v1);

9871

    // Rule at src/isa/x64/inst.isle line 5134.

9872

    return v2.clone();

9873

9874

9875

// Generated as internal constructor for term amode_to_gpr_mem.

9876

pub fn constructor_amode_to_gpr_mem<C: Context>(ctx: &mut C, arg0: &Amode) -> GprMem {

9877

    let v1 = &C::amode_to_synthetic_amode(ctx, arg0);

9878

    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, v1);

9879

    // Rule at src/isa/x64/inst.isle line 5132.

9880

    return v2.clone();

9881

9882

9883

// Generated as internal constructor for term amode_to_xmm_mem.

9884

pub fn constructor_amode_to_xmm_mem<C: Context>(ctx: &mut C, arg0: &Amode) -> XmmMem {

9885

    let v1 = &C::amode_to_synthetic_amode(ctx, arg0);

9886

    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, v1);

9887

    // Rule at src/isa/x64/inst.isle line 5137.

9888

    return v2.clone();

9889

9890

9891

// Generated as internal constructor for term synthetic_amode_to_xmm_mem.

9892

pub fn constructor_synthetic_amode_to_xmm_mem<C: Context>(

9893

    ctx: &mut C,

9894

    arg0: &SyntheticAmode,

9895

) -> XmmMem {

9896

    let v1 = &C::synthetic_amode_to_reg_mem(ctx, arg0);

9897

    let v2 = &C::reg_mem_to_xmm_mem(ctx, v1);

9898

    // Rule at src/isa/x64/inst.isle line 5140.

9899

    return v2.clone();

9900

9901

9902

// Generated as internal constructor for term const_to_xmm_mem.

9903

pub fn constructor_const_to_xmm_mem<C: Context>(ctx: &mut C, arg0: VCodeConstant) -> XmmMem {

9904

    let v1 = &C::const_to_synthetic_amode(ctx, arg0);

9905

    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, v1);

9906

    // Rule at src/isa/x64/inst.isle line 5145.

9907

    return v2.clone();

9908

9909

9910

// Generated as internal constructor for term const_to_reg_mem.

9911

pub fn constructor_const_to_reg_mem<C: Context>(ctx: &mut C, arg0: VCodeConstant) -> RegMem {

9912

    let v1 = &C::const_to_synthetic_amode(ctx, arg0);

9913

    let v2 = RegMem::Mem { addr: v1.clone() };

9914

    // Rule at src/isa/x64/inst.isle line 5147.

9915

    return v2;

9916

9917

9918

// Generated as internal constructor for term xmm_to_xmm_mem_aligned.

9919

pub fn constructor_xmm_to_xmm_mem_aligned<C: Context>(ctx: &mut C, arg0: Xmm) -> XmmMemAligned {

9920

    let v1 = &C::xmm_to_xmm_mem(ctx, arg0);

9921

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, v1);

9922

    // Rule at src/isa/x64/inst.isle line 5150.

9923

    return v2.clone();

9924

9925

9926

// Generated as internal constructor for term amode_to_xmm_mem_aligned.

9927

pub fn constructor_amode_to_xmm_mem_aligned<C: Context>(

9928

    ctx: &mut C,

9929

    arg0: &Amode,

9930

) -> XmmMemAligned {

9931

    let v1 = &constructor_amode_to_xmm_mem(ctx, arg0);

9932

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, v1);

9933

    // Rule at src/isa/x64/inst.isle line 5152.

9934

    return v2.clone();

9935

9936

9937

// Generated as internal constructor for term synthetic_amode_to_xmm_mem_aligned.

9938

pub fn constructor_synthetic_amode_to_xmm_mem_aligned<C: Context>(

9939

    ctx: &mut C,

9940

    arg0: &SyntheticAmode,

9941

) -> XmmMemAligned {

9942

    let v1 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);

9943

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, v1);

9944

    // Rule at src/isa/x64/inst.isle line 5154.

9945

    return v2.clone();

9946

9947

9948

// Generated as internal constructor for term put_in_xmm_mem_aligned.

9949

pub fn constructor_put_in_xmm_mem_aligned<C: Context>(ctx: &mut C, arg0: Value) -> XmmMemAligned {

9950

    let v1 = &C::put_in_xmm_mem(ctx, arg0);

9951

    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, v1);

9952

    // Rule at src/isa/x64/inst.isle line 5156.

9953

    return v2.clone();

9954

9955

9956

// Generated as internal constructor for term mov_to_preg.

9957

pub fn constructor_mov_to_preg<C: Context>(

9958

    ctx: &mut C,

9959

    arg0: PReg,

9960

    arg1: Gpr,

9961

) -> SideEffectNoResult {

9962

    let v2 = MInst::MovToPReg {

9963

        src: arg1,

9964

        dst: arg0,

9965

};

9966

    let v3 = SideEffectNoResult::Inst { inst: v2 };

9967

    // Rule at src/isa/x64/inst.isle line 5159.

9968

    return v3;

9969

9970

9971

// Generated as internal constructor for term x64_rbp.

9972

pub fn constructor_x64_rbp<C: Context>(ctx: &mut C) -> Reg {

9973

    let v0 = C::preg_rbp(ctx);

9974

    let v1 = constructor_mov_from_preg(ctx, v0);

9975

    // Rule at src/isa/x64/inst.isle line 5172.

9976

    return v1;

9977

9978

9979

// Generated as internal constructor for term x64_rsp.

9980

pub fn constructor_x64_rsp<C: Context>(ctx: &mut C) -> Reg {

9981

    let v0 = C::preg_rsp(ctx);

9982

    let v1 = constructor_mov_from_preg(ctx, v0);

9983

    // Rule at src/isa/x64/inst.isle line 5176.

9984

    return v1;

9985

9986

9987

// Generated as internal constructor for term lower.

9988

pub fn constructor_lower<C: Context>(ctx: &mut C, arg0: Inst) -> Option<InstOutput> {

9989

    let v6 = &C::inst_data(ctx, arg0);

9990

    match v6 {

9991

        &InstructionData::AtomicCas {

9992

            opcode: ref v1728,

9993

            args: ref v1729,

9994

            flags: v1730,

9995

        } => {

9996

            if let &Opcode::AtomicCas = v1728 {

9997

                let v1 = C::first_result(ctx, arg0);

9998

                if let Some(v2) = v1 {

9999

                    let v3 = C::value_type(ctx, v2);

10000

                    let v4 = C::fits_in_64(ctx, v3);

10001

                    if let Some(v5) = v4 {

10002

                        let v1703 = C::ty_int(ctx, v3);

10003

                        if let Some(v1704) = v1703 {

10004

                            let v1731 = C::unpack_value_array_3(ctx, v1729);

10005

                            let v1735 = constructor_put_in_gpr(ctx, v1731.1);

10006

                            let v1736 = constructor_put_in_gpr(ctx, v1731.2);

10007

                            let v1737 = C::zero_offset(ctx);

10008

                            let v1738 = &constructor_to_amode(ctx, v1730, v1731.0, v1737);

10009

                            let v1739 = &C::amode_to_synthetic_amode(ctx, v1738);

10010

                            let v1740 = constructor_x64_cmpxchg(ctx, v5, v1735, v1736, v1739);

10011

                            let v1741 = constructor_output_gpr(ctx, v1740);

10012

                            // Rule at src/isa/x64/lower.isle line 3215.

10013

                            return Some(v1741);

10014

10015

10016

10017

10018

10019

        &InstructionData::AtomicRmw {

10020

            opcode: ref v1742,

10021

            args: ref v1743,

10022

            flags: v1744,

10023

            op: ref v1745,

10024

        } => {

10025

            if let &Opcode::AtomicRmw = v1742 {

10026

                let v1 = C::first_result(ctx, arg0);

10027

                if let Some(v2) = v1 {

10028

                    let v3 = C::value_type(ctx, v2);

10029

                    let v4 = C::fits_in_64(ctx, v3);

10030

                    if let Some(v5) = v4 {

10031

                        let v1703 = C::ty_int(ctx, v3);

10032

                        if let Some(v1704) = v1703 {

10033

                            let v1749 = &C::atomic_rmw_op_to_mach_atomic_rmw_op(ctx, v1745);

10034

                            let v1705 = C::zero_offset(ctx);

10035

                            let v1746 = C::unpack_value_array_2(ctx, v1743);

10036

                            let v1750 = &constructor_to_amode(ctx, v1744, v1746.0, v1705);

10037

                            let v1751 = &C::amode_to_synthetic_amode(ctx, v1750);

10038

                            let v1752 = constructor_put_in_gpr(ctx, v1746.1);

10039

                            let v1753 =

10040

                                constructor_x64_atomic_rmw_seq(ctx, v5, v1749, v1751, v1752);

10041

                            let v1754 = constructor_output_gpr(ctx, v1753);

10042

                            // Rule at src/isa/x64/lower.isle line 3231.

10043

                            return Some(v1754);

10044

10045

10046

10047

10048

10049

        &InstructionData::Binary {

10050

            opcode: ref v36,

10051

            args: ref v37,

10052

        } => {

10053

            match v36 {

10054

                &Opcode::Swizzle => {

10055

                    let v38 = C::unpack_value_array_2(ctx, v37);

10056

                    let v1249 = constructor_put_in_xmm(ctx, v38.1);

10057

                    let v2354 = C::emit_u128_le_const(ctx, 0x70707070707070707070707070707070);

10058

                    let v2355 = &constructor_const_to_xmm_mem(ctx, v2354);

10059

                    let v2356 = constructor_x64_paddusb(ctx, v1249, v2355);

10060

                    let v343 = constructor_put_in_xmm(ctx, v38.0);

10061

                    let v2357 = C::xmm_to_reg(ctx, v2356);

10062

                    let v2358 = &constructor_xmm_to_reg_mem(ctx, v2357);

10063

                    let v2359 = &C::xmm_mem_to_reg_mem(ctx, v2358);

10064

                    let v2360 = constructor_lower_pshufb(ctx, v343, v2359);

10065

                    let v2361 = constructor_output_xmm(ctx, v2360);

10066

                    // Rule at src/isa/x64/lower.isle line 4341.

10067

                    return Some(v2361);

10068

10069

                &Opcode::X86Pshufb => {

10070

                    let v525 = C::use_ssse3(ctx);

10071

                    if v525 == true {

10072

                        let v38 = C::unpack_value_array_2(ctx, v37);

10073

                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10074

                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10075

                        let v2362 = constructor_x64_pshufb(ctx, v68, v69);

10076

                        let v2363 = constructor_output_xmm(ctx, v2362);

10077

                        // Rule at src/isa/x64/lower.isle line 4347.

10078

                        return Some(v2363);

10079

10080

10081

                &Opcode::Smin => {

10082

                    let v1 = C::first_result(ctx, arg0);

10083

                    if let Some(v2) = v1 {

10084

                        let v3 = C::value_type(ctx, v2);

10085

                        let v740 = C::ty_vec128(ctx, v3);

10086

                        if let Some(v741) = v740 {

10087

                            let v744 = constructor_has_pmins(ctx, v741);

10088

                            if v744 == true {

10089

                                let v38 = C::unpack_value_array_2(ctx, v37);

10090

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

10091

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10092

                                let v745 = constructor_x64_pmins(ctx, v741, v68, v69);

10093

                                let v746 = constructor_output_xmm(ctx, v745);

10094

                                // Rule at src/isa/x64/lower.isle line 1687.

10095

                                return Some(v746);

10096

10097

                            let v38 = C::unpack_value_array_2(ctx, v37);

10098

                            let v68 = constructor_put_in_xmm(ctx, v38.0);

10099

                            let v444 = constructor_put_in_xmm(ctx, v38.1);

10100

                            let v316 = &C::xmm_to_xmm_mem(ctx, v68);

10101

                            let v747 = constructor_x64_pcmpgt(ctx, v741, v444, v316);

10102

                            let v318 = &C::xmm_to_xmm_mem(ctx, v68);

10103

                            let v748 = constructor_x64_pand(ctx, v747, v318);

10104

                            let v449 = &C::xmm_to_xmm_mem(ctx, v444);

10105

                            let v749 = constructor_x64_pandn(ctx, v747, v449);

10106

                            let v750 = &C::xmm_to_xmm_mem(ctx, v749);

10107

                            let v751 = constructor_x64_por(ctx, v748, v750);

10108

                            let v752 = constructor_output_xmm(ctx, v751);

10109

                            // Rule at src/isa/x64/lower.isle line 1691.

10110

                            return Some(v752);

10111

10112

                        let v4 = C::fits_in_64(ctx, v3);

10113

                        if let Some(v5) = v4 {

10114

                            let v38 = C::unpack_value_array_2(ctx, v37);

10115

                            let v735 = constructor_cmp_and_choose(ctx, v5, &CC::L, v38.0, v38.1);

10116

                            let v736 = C::output(ctx, v735);

10117

                            // Rule at src/isa/x64/lower.isle line 1637.

10118

                            return Some(v736);

10119

10120

10121

10122

                &Opcode::Umin => {

10123

                    let v1 = C::first_result(ctx, arg0);

10124

                    if let Some(v2) = v1 {

10125

                        let v3 = C::value_type(ctx, v2);

10126

                        let v740 = C::ty_vec128(ctx, v3);

10127

                        if let Some(v741) = v740 {

10128

                            let v774 = constructor_has_pminu(ctx, v741);

10129

                            if v774 == true {

10130

                                let v38 = C::unpack_value_array_2(ctx, v37);

10131

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

10132

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10133

                                let v775 = constructor_x64_pminu(ctx, v741, v68, v69);

10134

                                let v776 = constructor_output_xmm(ctx, v775);

10135

                                // Rule at src/isa/x64/lower.isle line 1739.

10136

                                return Some(v776);

10137

10138

10139

                        if v3 == I16X8 {

10140

                            let v38 = C::unpack_value_array_2(ctx, v37);

10141

                            let v68 = constructor_put_in_xmm(ctx, v38.0);

10142

                            let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10143

                            let v150 = constructor_x64_psubusw(ctx, v68, v69);

10144

                            let v777 = &C::xmm_to_xmm_mem(ctx, v150);

10145

                            let v778 = constructor_x64_psubw(ctx, v68, v777);

10146

                            let v779 = constructor_output_xmm(ctx, v778);

10147

                            // Rule at src/isa/x64/lower.isle line 1745.

10148

                            return Some(v779);

10149

10150

                        if let Some(v741) = v740 {

10151

                            let v38 = C::unpack_value_array_2(ctx, v37);

10152

                            let v68 = constructor_put_in_xmm(ctx, v38.0);

10153

                            let v444 = constructor_put_in_xmm(ctx, v38.1);

10154

                            let v760 = constructor_flip_high_bit_mask(ctx, v741);

10155

                            let v761 = &C::xmm_to_xmm_mem(ctx, v760);

10156

                            let v762 = constructor_x64_pxor(ctx, v68, v761);

10157

                            let v763 = &C::xmm_to_xmm_mem(ctx, v760);

10158

                            let v764 = constructor_x64_pxor(ctx, v444, v763);

10159

                            let v780 = &C::xmm_to_xmm_mem(ctx, v762);

10160

                            let v781 = constructor_x64_pcmpgt(ctx, v741, v764, v780);

10161

                            let v767 = &C::xmm_to_xmm_mem(ctx, v68);

10162

                            let v782 = constructor_x64_pand(ctx, v781, v767);

10163

                            let v769 = &C::xmm_to_xmm_mem(ctx, v444);

10164

                            let v783 = constructor_x64_pandn(ctx, v781, v769);

10165

                            let v784 = &C::xmm_to_xmm_mem(ctx, v783);

10166

                            let v785 = constructor_x64_por(ctx, v782, v784);

10167

                            let v786 = constructor_output_xmm(ctx, v785);

10168

                            // Rule at src/isa/x64/lower.isle line 1750.

10169

                            return Some(v786);

10170

10171

                        let v4 = C::fits_in_64(ctx, v3);

10172

                        if let Some(v5) = v4 {

10173

                            let v38 = C::unpack_value_array_2(ctx, v37);

10174

                            let v729 = constructor_cmp_and_choose(ctx, v5, &CC::B, v38.0, v38.1);

10175

                            let v730 = C::output(ctx, v729);

10176

                            // Rule at src/isa/x64/lower.isle line 1631.

10177

                            return Some(v730);

10178

10179

10180

10181

                &Opcode::Smax => {

10182

                    let v1 = C::first_result(ctx, arg0);

10183

                    if let Some(v2) = v1 {

10184

                        let v3 = C::value_type(ctx, v2);

10185

                        let v740 = C::ty_vec128(ctx, v3);

10186

                        if let Some(v741) = v740 {

10187

                            let v38 = C::unpack_value_array_2(ctx, v37);

10188

                            let v68 = constructor_put_in_xmm(ctx, v38.0);

10189

                            let v444 = constructor_put_in_xmm(ctx, v38.1);

10190

                            let v742 = constructor_lower_vec_smax(ctx, v741, v68, v444);

10191

                            let v743 = constructor_output_xmm(ctx, v742);

10192

                            // Rule at src/isa/x64/lower.isle line 1667.

10193

                            return Some(v743);

10194

10195

                        let v4 = C::fits_in_64(ctx, v3);

10196

                        if let Some(v5) = v4 {

10197

                            let v38 = C::unpack_value_array_2(ctx, v37);

10198

                            let v738 = constructor_cmp_and_choose(ctx, v5, &CC::NL, v38.0, v38.1);

10199

                            let v739 = C::output(ctx, v738);

10200

                            // Rule at src/isa/x64/lower.isle line 1640.

10201

                            return Some(v739);

10202

10203

10204

10205

                &Opcode::Umax => {

10206

                    let v1 = C::first_result(ctx, arg0);

10207

                    if let Some(v2) = v1 {

10208

                        let v3 = C::value_type(ctx, v2);

10209

                        let v740 = C::ty_vec128(ctx, v3);

10210

                        if let Some(v741) = v740 {

10211

                            let v753 = constructor_has_pmaxu(ctx, v741);

10212

                            if v753 == true {

10213

                                let v38 = C::unpack_value_array_2(ctx, v37);

10214

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

10215

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10216

                                let v754 = constructor_x64_pmaxu(ctx, v741, v68, v69);

10217

                                let v755 = constructor_output_xmm(ctx, v754);

10218

                                // Rule at src/isa/x64/lower.isle line 1703.

10219

                                return Some(v755);

10220

10221

10222

                        if v3 == I16X8 {

10223

                            let v38 = C::unpack_value_array_2(ctx, v37);

10224

                            let v68 = constructor_put_in_xmm(ctx, v38.0);

10225

                            let v444 = constructor_put_in_xmm(ctx, v38.1);

10226

                            let v316 = &C::xmm_to_xmm_mem(ctx, v68);

10227

                            let v756 = constructor_x64_psubusw(ctx, v444, v316);

10228

                            let v757 = &C::xmm_to_xmm_mem(ctx, v756);

10229

                            let v758 = constructor_x64_paddw(ctx, v68, v757);

10230

                            let v759 = constructor_output_xmm(ctx, v758);

10231

                            // Rule at src/isa/x64/lower.isle line 1709.

10232

                            return Some(v759);

10233

10234

                        if let Some(v741) = v740 {

10235

                            let v38 = C::unpack_value_array_2(ctx, v37);

10236

                            let v68 = constructor_put_in_xmm(ctx, v38.0);

10237

                            let v444 = constructor_put_in_xmm(ctx, v38.1);

10238

                            let v760 = constructor_flip_high_bit_mask(ctx, v741);

10239

                            let v761 = &C::xmm_to_xmm_mem(ctx, v760);

10240

                            let v762 = constructor_x64_pxor(ctx, v68, v761);

10241

                            let v763 = &C::xmm_to_xmm_mem(ctx, v760);

10242

                            let v764 = constructor_x64_pxor(ctx, v444, v763);

10243

                            let v765 = &C::xmm_to_xmm_mem(ctx, v764);

10244

                            let v766 = constructor_x64_pcmpgt(ctx, v741, v762, v765);

10245

                            let v767 = &C::xmm_to_xmm_mem(ctx, v68);

10246

                            let v768 = constructor_x64_pand(ctx, v766, v767);

10247

                            let v769 = &C::xmm_to_xmm_mem(ctx, v444);

10248

                            let v770 = constructor_x64_pandn(ctx, v766, v769);

10249

                            let v771 = &C::xmm_to_xmm_mem(ctx, v770);

10250

                            let v772 = constructor_x64_por(ctx, v768, v771);

10251

                            let v773 = constructor_output_xmm(ctx, v772);

10252

                            // Rule at src/isa/x64/lower.isle line 1716.

10253

                            return Some(v773);

10254

10255

                        let v4 = C::fits_in_64(ctx, v3);

10256

                        if let Some(v5) = v4 {

10257

                            let v38 = C::unpack_value_array_2(ctx, v37);

10258

                            let v732 = constructor_cmp_and_choose(ctx, v5, &CC::NB, v38.0, v38.1);

10259

                            let v733 = C::output(ctx, v732);

10260

                            // Rule at src/isa/x64/lower.isle line 1634.

10261

                            return Some(v733);

10262

10263

10264

10265

                &Opcode::AvgRound => {

10266

                    let v1 = C::first_result(ctx, arg0);

10267

                    if let Some(v2) = v1 {

10268

                        let v3 = C::value_type(ctx, v2);

10269

                        let v64 = C::multi_lane(ctx, v3);

10270

                        if let Some(v65) = v64 {

10271

                            match v65.0 {

10272

                                0x8 => {

10273

                                    if v65.1 == 0x10 {

10274

                                        let v38 = C::unpack_value_array_2(ctx, v37);

10275

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10276

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10277

                                        let v415 = constructor_x64_pavgb(ctx, v68, v69);

10278

                                        let v416 = constructor_output_xmm(ctx, v415);

10279

                                        // Rule at src/isa/x64/lower.isle line 956.

10280

                                        return Some(v416);

10281

10282

10283

                                0x10 => {

10284

                                    if v65.1 == 0x8 {

10285

                                        let v38 = C::unpack_value_array_2(ctx, v37);

10286

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10287

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10288

                                        let v417 = constructor_x64_pavgw(ctx, v68, v69);

10289

                                        let v418 = constructor_output_xmm(ctx, v417);

10290

                                        // Rule at src/isa/x64/lower.isle line 960.

10291

                                        return Some(v418);

10292

10293

10294

                                _ => {}

10295

10296

10297

10298

10299

                &Opcode::UaddSat => {

10300

                    let v1 = C::first_result(ctx, arg0);

10301

                    if let Some(v2) = v1 {

10302

                        let v3 = C::value_type(ctx, v2);

10303

                        let v64 = C::multi_lane(ctx, v3);

10304

                        if let Some(v65) = v64 {

10305

                            match v65.0 {

10306

                                0x8 => {

10307

                                    if v65.1 == 0x10 {

10308

                                        let v38 = C::unpack_value_array_2(ctx, v37);

10309

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10310

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10311

                                        let v126 = constructor_x64_paddusb(ctx, v68, v69);

10312

                                        let v127 = constructor_output_xmm(ctx, v126);

10313

                                        // Rule at src/isa/x64/lower.isle line 194.

10314

                                        return Some(v127);

10315

10316

10317

                                0x10 => {

10318

                                    if v65.1 == 0x8 {

10319

                                        let v38 = C::unpack_value_array_2(ctx, v37);

10320

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10321

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10322

                                        let v128 = constructor_x64_paddusw(ctx, v68, v69);

10323

                                        let v129 = constructor_output_xmm(ctx, v128);

10324

                                        // Rule at src/isa/x64/lower.isle line 198.

10325

                                        return Some(v129);

10326

10327

10328

                                _ => {}

10329

10330

10331

10332

10333

                &Opcode::SaddSat => {

10334

                    let v1 = C::first_result(ctx, arg0);

10335

                    if let Some(v2) = v1 {

10336

                        let v3 = C::value_type(ctx, v2);

10337

                        let v64 = C::multi_lane(ctx, v3);

10338

                        if let Some(v65) = v64 {

10339

                            match v65.0 {

10340

                                0x8 => {

10341

                                    if v65.1 == 0x10 {

10342

                                        let v38 = C::unpack_value_array_2(ctx, v37);

10343

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10344

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10345

                                        let v122 = constructor_x64_paddsb(ctx, v68, v69);

10346

                                        let v123 = constructor_output_xmm(ctx, v122);

10347

                                        // Rule at src/isa/x64/lower.isle line 184.

10348

                                        return Some(v123);

10349

10350

10351

                                0x10 => {

10352

                                    if v65.1 == 0x8 {

10353

                                        let v38 = C::unpack_value_array_2(ctx, v37);

10354

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10355

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10356

                                        let v124 = constructor_x64_paddsw(ctx, v68, v69);

10357

                                        let v125 = constructor_output_xmm(ctx, v124);

10358

                                        // Rule at src/isa/x64/lower.isle line 188.

10359

                                        return Some(v125);

10360

10361

10362

                                _ => {}

10363

10364

10365

10366

10367

                &Opcode::UsubSat => {

10368

                    let v1 = C::first_result(ctx, arg0);

10369

                    if let Some(v2) = v1 {

10370

                        let v3 = C::value_type(ctx, v2);

10371

                        let v64 = C::multi_lane(ctx, v3);

10372

                        if let Some(v65) = v64 {

10373

                            match v65.0 {

10374

                                0x8 => {

10375

                                    if v65.1 == 0x10 {

10376

                                        let v38 = C::unpack_value_array_2(ctx, v37);

10377

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10378

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10379

                                        let v148 = constructor_x64_psubusb(ctx, v68, v69);

10380

                                        let v149 = constructor_output_xmm(ctx, v148);

10381

                                        // Rule at src/isa/x64/lower.isle line 255.

10382

                                        return Some(v149);

10383

10384

10385

                                0x10 => {

10386

                                    if v65.1 == 0x8 {

10387

                                        let v38 = C::unpack_value_array_2(ctx, v37);

10388

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10389

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10390

                                        let v150 = constructor_x64_psubusw(ctx, v68, v69);

10391

                                        let v151 = constructor_output_xmm(ctx, v150);

10392

                                        // Rule at src/isa/x64/lower.isle line 259.

10393

                                        return Some(v151);

10394

10395

10396

                                _ => {}

10397

10398

10399

10400

10401

                &Opcode::SsubSat => {

10402

                    let v1 = C::first_result(ctx, arg0);

10403

                    if let Some(v2) = v1 {

10404

                        let v3 = C::value_type(ctx, v2);

10405

                        let v64 = C::multi_lane(ctx, v3);

10406

                        if let Some(v65) = v64 {

10407

                            match v65.0 {

10408

                                0x8 => {

10409

                                    if v65.1 == 0x10 {

10410

                                        let v38 = C::unpack_value_array_2(ctx, v37);

10411

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10412

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10413

                                        let v144 = constructor_x64_psubsb(ctx, v68, v69);

10414

                                        let v145 = constructor_output_xmm(ctx, v144);

10415

                                        // Rule at src/isa/x64/lower.isle line 245.

10416

                                        return Some(v145);

10417

10418

10419

                                0x10 => {

10420

                                    if v65.1 == 0x8 {

10421

                                        let v38 = C::unpack_value_array_2(ctx, v37);

10422

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10423

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10424

                                        let v146 = constructor_x64_psubsw(ctx, v68, v69);

10425

                                        let v147 = constructor_output_xmm(ctx, v146);

10426

                                        // Rule at src/isa/x64/lower.isle line 249.

10427

                                        return Some(v147);

10428

10429

10430

                                _ => {}

10431

10432

10433

10434

10435

                &Opcode::Iadd => {

10436

                    let v1 = C::first_result(ctx, arg0);

10437

                    if let Some(v2) = v1 {

10438

                        let v3 = C::value_type(ctx, v2);

10439

                        if v3 == I128 {

10440

                            let v38 = C::unpack_value_array_2(ctx, v37);

10441

                            let v78 = C::put_in_regs(ctx, v38.0);

10442

                            let v80 = constructor_value_regs_get_gpr(ctx, v78, 0x0);

10443

                            let v82 = constructor_value_regs_get_gpr(ctx, v78, 0x1);

10444

                            let v83 = C::put_in_regs(ctx, v38.1);

10445

                            let v84 = constructor_value_regs_get_gpr(ctx, v83, 0x0);

10446

                            let v85 = constructor_value_regs_get_gpr(ctx, v83, 0x1);

10447

                            let v86 = &C::gpr_to_gpr_mem_imm(ctx, v84);

10448

                            let v87 = &constructor_x64_add_with_flags_paired(ctx, I64, v80, v86);

10449

                            let v88 = &C::gpr_to_gpr_mem_imm(ctx, v85);

10450

                            let v89 = &constructor_x64_adc_paired(ctx, I64, v82, v88);

10451

                            let v90 = constructor_with_flags(ctx, v87, v89);

10452

                            let v91 = C::output(ctx, v90);

10453

                            // Rule at src/isa/x64/lower.isle line 88.

10454

                            return Some(v91);

10455

10456

                        let v64 = C::multi_lane(ctx, v3);

10457

                        if let Some(v65) = v64 {

10458

                            match v65.0 {

10459

                                0x8 => {

10460

                                    if v65.1 == 0x10 {

10461

                                        let v38 = C::unpack_value_array_2(ctx, v37);

10462

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10463

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10464

                                        let v70 = constructor_x64_paddb(ctx, v68, v69);

10465

                                        let v71 = constructor_output_xmm(ctx, v70);

10466

                                        // Rule at src/isa/x64/lower.isle line 71.

10467

                                        return Some(v71);

10468

10469

10470

                                0x10 => {

10471

                                    if v65.1 == 0x8 {

10472

                                        let v38 = C::unpack_value_array_2(ctx, v37);

10473

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10474

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10475

                                        let v72 = constructor_x64_paddw(ctx, v68, v69);

10476

                                        let v73 = constructor_output_xmm(ctx, v72);

10477

                                        // Rule at src/isa/x64/lower.isle line 75.

10478

                                        return Some(v73);

10479

10480

10481

                                0x20 => {

10482

                                    if v65.1 == 0x4 {

10483

                                        let v38 = C::unpack_value_array_2(ctx, v37);

10484

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10485

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10486

                                        let v74 = constructor_x64_paddd(ctx, v68, v69);

10487

                                        let v75 = constructor_output_xmm(ctx, v74);

10488

                                        // Rule at src/isa/x64/lower.isle line 79.

10489

                                        return Some(v75);

10490

10491

10492

                                0x40 => {

10493

                                    if v65.1 == 0x2 {

10494

                                        let v38 = C::unpack_value_array_2(ctx, v37);

10495

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10496

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10497

                                        let v76 = constructor_x64_paddq(ctx, v68, v69);

10498

                                        let v77 = constructor_output_xmm(ctx, v76);

10499

                                        // Rule at src/isa/x64/lower.isle line 83.

10500

                                        return Some(v77);

10501

10502

10503

                                _ => {}

10504

10505

10506

                        let v4 = C::fits_in_64(ctx, v3);

10507

                        if let Some(v5) = v4 {

10508

                            let v38 = C::unpack_value_array_2(ctx, v37);

10509

                            let v58 = &C::sinkable_load(ctx, v38.0);

10510

                            if let Some(v59) = v58 {

10511

                                let v60 = constructor_put_in_gpr(ctx, v38.1);

10512

                                let v61 = &constructor_sink_load_to_gpr_mem_imm(ctx, v59);

10513

                                let v62 = constructor_x64_add(ctx, v5, v60, v61);

10514

                                let v63 = constructor_output_gpr(ctx, v62);

10515

                                // Rule at src/isa/x64/lower.isle line 65.

10516

                                return Some(v63);

10517

10518

                            let v53 = &C::sinkable_load(ctx, v38.1);

10519

                            if let Some(v54) = v53 {

10520

                                let v41 = constructor_put_in_gpr(ctx, v38.0);

10521

                                let v55 = &constructor_sink_load_to_gpr_mem_imm(ctx, v54);

10522

                                let v56 = constructor_x64_add(ctx, v5, v41, v55);

10523

                                let v57 = constructor_output_gpr(ctx, v56);

10524

                                // Rule at src/isa/x64/lower.isle line 62.

10525

                                return Some(v57);

10526

10527

10528

                        let v45 = C::ty_32_or_64(ctx, v3);

10529

                        if let Some(v46) = v45 {

10530

                            let v48 = C::zero_offset(ctx);

10531

                            let v47 = C::mem_flags_trusted(ctx);

10532

                            let v38 = C::unpack_value_array_2(ctx, v37);

10533

                            let v49 = &constructor_to_amode_add(ctx, v47, v38.0, v38.1, v48);

10534

                            let v50 = &C::amode_to_synthetic_amode(ctx, v49);

10535

                            let v51 = constructor_x64_lea(ctx, v46, v50);

10536

                            let v52 = constructor_output_gpr(ctx, v51);

10537

                            // Rule at src/isa/x64/lower.isle line 56.

10538

                            return Some(v52);

10539

10540

                        let v34 = C::fits_in_16(ctx, v3);

10541

                        if let Some(v35) = v34 {

10542

                            let v38 = C::unpack_value_array_2(ctx, v37);

10543

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

10544

                            let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);

10545

                            let v43 = constructor_x64_add(ctx, v35, v41, v42);

10546

                            let v44 = constructor_output_gpr(ctx, v43);

10547

                            // Rule at src/isa/x64/lower.isle line 45.

10548

                            return Some(v44);

10549

10550

10551

10552

                &Opcode::Isub => {

10553

                    let v1 = C::first_result(ctx, arg0);

10554

                    if let Some(v2) = v1 {

10555

                        let v3 = C::value_type(ctx, v2);

10556

                        if v3 == I128 {

10557

                            let v38 = C::unpack_value_array_2(ctx, v37);

10558

                            let v78 = C::put_in_regs(ctx, v38.0);

10559

                            let v80 = constructor_value_regs_get_gpr(ctx, v78, 0x0);

10560

                            let v82 = constructor_value_regs_get_gpr(ctx, v78, 0x1);

10561

                            let v83 = C::put_in_regs(ctx, v38.1);

10562

                            let v84 = constructor_value_regs_get_gpr(ctx, v83, 0x0);

10563

                            let v85 = constructor_value_regs_get_gpr(ctx, v83, 0x1);

10564

                            let v86 = &C::gpr_to_gpr_mem_imm(ctx, v84);

10565

                            let v140 = &constructor_x64_sub_with_flags_paired(ctx, I64, v80, v86);

10566

                            let v88 = &C::gpr_to_gpr_mem_imm(ctx, v85);

10567

                            let v141 = &constructor_x64_sbb_paired(ctx, I64, v82, v88);

10568

                            let v142 = constructor_with_flags(ctx, v140, v141);

10569

                            let v143 = C::output(ctx, v142);

10570

                            // Rule at src/isa/x64/lower.isle line 230.

10571

                            return Some(v143);

10572

10573

                        let v64 = C::multi_lane(ctx, v3);

10574

                        if let Some(v65) = v64 {

10575

                            match v65.0 {

10576

                                0x8 => {

10577

                                    if v65.1 == 0x10 {

10578

                                        let v38 = C::unpack_value_array_2(ctx, v37);

10579

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10580

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10581

                                        let v132 = constructor_x64_psubb(ctx, v68, v69);

10582

                                        let v133 = constructor_output_xmm(ctx, v132);

10583

                                        // Rule at src/isa/x64/lower.isle line 213.

10584

                                        return Some(v133);

10585

10586

10587

                                0x10 => {

10588

                                    if v65.1 == 0x8 {

10589

                                        let v38 = C::unpack_value_array_2(ctx, v37);

10590

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10591

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10592

                                        let v134 = constructor_x64_psubw(ctx, v68, v69);

10593

                                        let v135 = constructor_output_xmm(ctx, v134);

10594

                                        // Rule at src/isa/x64/lower.isle line 217.

10595

                                        return Some(v135);

10596

10597

10598

                                0x20 => {

10599

                                    if v65.1 == 0x4 {

10600

                                        let v38 = C::unpack_value_array_2(ctx, v37);

10601

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10602

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10603

                                        let v136 = constructor_x64_psubd(ctx, v68, v69);

10604

                                        let v137 = constructor_output_xmm(ctx, v136);

10605

                                        // Rule at src/isa/x64/lower.isle line 221.

10606

                                        return Some(v137);

10607

10608

10609

                                0x40 => {

10610

                                    if v65.1 == 0x2 {

10611

                                        let v38 = C::unpack_value_array_2(ctx, v37);

10612

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10613

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10614

                                        let v138 = constructor_x64_psubq(ctx, v68, v69);

10615

                                        let v139 = constructor_output_xmm(ctx, v138);

10616

                                        // Rule at src/isa/x64/lower.isle line 225.

10617

                                        return Some(v139);

10618

10619

10620

                                _ => {}

10621

10622

10623

                        let v4 = C::fits_in_64(ctx, v3);

10624

                        if let Some(v5) = v4 {

10625

                            let v38 = C::unpack_value_array_2(ctx, v37);

10626

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

10627

                            let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);

10628

                            let v130 = constructor_x64_sub(ctx, v5, v41, v42);

10629

                            let v131 = constructor_output_gpr(ctx, v130);

10630

                            // Rule at src/isa/x64/lower.isle line 207.

10631

                            return Some(v131);

10632

10633

10634

10635

                &Opcode::Imul => {

10636

                    let v1 = C::first_result(ctx, arg0);

10637

                    if let Some(v2) = v1 {

10638

                        let v3 = C::value_type(ctx, v2);

10639

                        let v64 = C::multi_lane(ctx, v3);

10640

                        if let Some(v65) = v64 {

10641

                            if v65.0 == 0x40 {

10642

                                if v65.1 == 0x2 {

10643

                                    let v332 = C::use_avx512vl(ctx);

10644

                                    if v332 == true {

10645

                                        let v461 = C::use_avx512dq(ctx);

10646

                                        if v461 == true {

10647

                                            let v38 = C::unpack_value_array_2(ctx, v37);

10648

                                            let v68 = constructor_put_in_xmm(ctx, v38.0);

10649

                                            let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10650

                                            let v462 = constructor_x64_vpmullq(ctx, v68, v69);

10651

                                            let v463 = constructor_output_xmm(ctx, v462);

10652

                                            // Rule at src/isa/x64/lower.isle line 1047.

10653

                                            return Some(v463);

10654

10655

10656

10657

10658

10659

                        if v3 == I128 {

10660

                            let v38 = C::unpack_value_array_2(ctx, v37);

10661

                            let v78 = C::put_in_regs(ctx, v38.0);

10662

                            let v80 = constructor_value_regs_get_gpr(ctx, v78, 0x0);

10663

                            let v82 = constructor_value_regs_get_gpr(ctx, v78, 0x1);

10664

                            let v83 = C::put_in_regs(ctx, v38.1);

10665

                            let v84 = constructor_value_regs_get_gpr(ctx, v83, 0x0);

10666

                            let v85 = constructor_value_regs_get_gpr(ctx, v83, 0x1);

10667

                            let v425 = &C::gpr_to_gpr_mem_imm(ctx, v85);

10668

                            let v426 = constructor_x64_mul(ctx, I64, v80, v425);

10669

                            let v427 = &C::gpr_to_gpr_mem_imm(ctx, v84);

10670

                            let v428 = constructor_x64_mul(ctx, I64, v82, v427);

10671

                            let v429 = &C::gpr_to_gpr_mem_imm(ctx, v428);

10672

                            let v430 = constructor_x64_add(ctx, I64, v426, v429);

10673

                            let v431 = &C::gpr_to_gpr_mem(ctx, v84);

10674

                            let v432 = constructor_mulhi_u(ctx, I64, v80, v431);

10675

                            let v433 = constructor_value_regs_get_gpr(ctx, v432, 0x0);

10676

                            let v434 = constructor_value_regs_get_gpr(ctx, v432, 0x1);

10677

                            let v435 = &C::gpr_to_gpr_mem_imm(ctx, v434);

10678

                            let v436 = constructor_x64_add(ctx, I64, v430, v435);

10679

                            let v437 = constructor_value_gprs(ctx, v433, v436);

10680

                            let v438 = C::output(ctx, v437);

10681

                            // Rule at src/isa/x64/lower.isle line 997.

10682

                            return Some(v438);

10683

10684

                        if let Some(v65) = v64 {

10685

                            match v65.0 {

10686

                                0x10 => {

10687

                                    if v65.1 == 0x8 {

10688

                                        let v38 = C::unpack_value_array_2(ctx, v37);

10689

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10690

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10691

                                        let v439 = constructor_x64_pmullw(ctx, v68, v69);

10692

                                        let v440 = constructor_output_xmm(ctx, v439);

10693

                                        // Rule at src/isa/x64/lower.isle line 1024.

10694

                                        return Some(v440);

10695

10696

10697

                                0x20 => {

10698

                                    if v65.1 == 0x4 {

10699

                                        let v38 = C::unpack_value_array_2(ctx, v37);

10700

                                        let v171 = C::def_inst(ctx, v38.1);

10701

                                        if let Some(v172) = v171 {

10702

                                            let v173 = &C::inst_data(ctx, v172);

10703

                                            if let &InstructionData::Unary {

10704

                                                opcode: ref v174,

10705

                                                arg: v175,

10706

                                            } = v173

10707

10708

                                                match v174 {

10709

                                                    &Opcode::SwidenLow => {

10710

                                                        let v180 = C::def_inst(ctx, v38.0);

10711

                                                        if let Some(v181) = v180 {

10712

                                                            let v182 = &C::inst_data(ctx, v181);

10713

                                                            if let &InstructionData::Unary {

10714

                                                                opcode: ref v183,

10715

                                                                arg: v184,

10716

                                                            } = v182

10717

10718

                                                                if let &Opcode::SwidenLow = v183 {

10719

                                                                    let v481 =

10720

                                                                        C::value_type(ctx, v184);

10721

                                                                    let v482 =

10722

                                                                        C::multi_lane(ctx, v481);

10723

                                                                    if let Some(v483) = v482 {

10724

                                                                        if v483.0 == 0x10 {

10725

                                                                            if v483.1 == 0x8 {

10726

                                                                                let v486 =

10727

                                                                                    C::value_type(

10728

                                                                                        ctx, v175,

10729

);

10730

                                                                                let v487 =

10731

                                                                                    C::multi_lane(

10732

                                                                                        ctx, v486,

10733

);

10734

                                                                                if let Some(v488) =

10735

                                                                                    v487

10736

10737

                                                                                    if v488.0

10738

                                                                                        == 0x10

10739

10740

                                                                                        if v488.1

10741

                                                                                            == 0x8

10742

10743

                                                                                            let v185 = constructor_put_in_xmm(ctx, v184);

10744

                                                                                            let v491 = constructor_put_in_xmm(ctx, v175);

10745

                                                                                            let v492 = &C::xmm_to_xmm_mem(ctx, v491);

10746

                                                                                            let v493 = constructor_x64_pmullw(ctx, v185, v492);

10747

                                                                                            let v494 = &C::xmm_to_xmm_mem(ctx, v491);

10748

                                                                                            let v495 = constructor_x64_pmulhw(ctx, v185, v494);

10749

                                                                                            let v496 = &C::xmm_to_xmm_mem(ctx, v495);

10750

                                                                                            let v507 = constructor_x64_punpcklwd(ctx, v493, v496);

10751

                                                                                            let v508 = constructor_output_xmm(ctx, v507);

10752

                                                                                            // Rule at src/isa/x64/lower.isle line 1117.

10753

                                                                                            return Some(v508);

10754

10755

10756

10757

10758

10759

10760

10761

10762

10763

10764

                                                    &Opcode::SwidenHigh => {

10765

                                                        let v180 = C::def_inst(ctx, v38.0);

10766

                                                        if let Some(v181) = v180 {

10767

                                                            let v182 = &C::inst_data(ctx, v181);

10768

                                                            if let &InstructionData::Unary {

10769

                                                                opcode: ref v183,

10770

                                                                arg: v184,

10771

                                                            } = v182

10772

10773

                                                                if let &Opcode::SwidenHigh = v183 {

10774

                                                                    let v481 =

10775

                                                                        C::value_type(ctx, v184);

10776

                                                                    let v482 =

10777

                                                                        C::multi_lane(ctx, v481);

10778

                                                                    if let Some(v483) = v482 {

10779

                                                                        if v483.0 == 0x10 {

10780

                                                                            if v483.1 == 0x8 {

10781

                                                                                let v486 =

10782

                                                                                    C::value_type(

10783

                                                                                        ctx, v175,

10784

);

10785

                                                                                let v487 =

10786

                                                                                    C::multi_lane(

10787

                                                                                        ctx, v486,

10788

);

10789

                                                                                if let Some(v488) =

10790

                                                                                    v487

10791

10792

                                                                                    if v488.0

10793

                                                                                        == 0x10

10794

10795

                                                                                        if v488.1

10796

                                                                                            == 0x8

10797

10798

                                                                                            let v185 = constructor_put_in_xmm(ctx, v184);

10799

                                                                                            let v491 = constructor_put_in_xmm(ctx, v175);

10800

                                                                                            let v492 = &C::xmm_to_xmm_mem(ctx, v491);

10801

                                                                                            let v493 = constructor_x64_pmullw(ctx, v185, v492);

10802

                                                                                            let v494 = &C::xmm_to_xmm_mem(ctx, v491);

10803

                                                                                            let v495 = constructor_x64_pmulhw(ctx, v185, v494);

10804

                                                                                            let v496 = &C::xmm_to_xmm_mem(ctx, v495);

10805

                                                                                            let v497 = constructor_x64_punpckhwd(ctx, v493, v496);

10806

                                                                                            let v498 = constructor_output_xmm(ctx, v497);

10807

                                                                                            // Rule at src/isa/x64/lower.isle line 1094.

10808

                                                                                            return Some(v498);

10809

10810

10811

10812

10813

10814

10815

10816

10817

10818

10819

                                                    &Opcode::UwidenLow => {

10820

                                                        let v180 = C::def_inst(ctx, v38.0);

10821

                                                        if let Some(v181) = v180 {

10822

                                                            let v182 = &C::inst_data(ctx, v181);

10823

                                                            if let &InstructionData::Unary {

10824

                                                                opcode: ref v183,

10825

                                                                arg: v184,

10826

                                                            } = v182

10827

10828

                                                                if let &Opcode::UwidenLow = v183 {

10829

                                                                    let v481 =

10830

                                                                        C::value_type(ctx, v184);

10831

                                                                    let v482 =

10832

                                                                        C::multi_lane(ctx, v481);

10833

                                                                    if let Some(v483) = v482 {

10834

                                                                        if v483.0 == 0x10 {

10835

                                                                            if v483.1 == 0x8 {

10836

                                                                                let v486 =

10837

                                                                                    C::value_type(

10838

                                                                                        ctx, v175,

10839

);

10840

                                                                                let v487 =

10841

                                                                                    C::multi_lane(

10842

                                                                                        ctx, v486,

10843

);

10844

                                                                                if let Some(v488) =

10845

                                                                                    v487

10846

10847

                                                                                    if v488.0

10848

                                                                                        == 0x10

10849

10850

                                                                                        if v488.1

10851

                                                                                            == 0x8

10852

10853

                                                                                            let v185 = constructor_put_in_xmm(ctx, v184);

10854

                                                                                            let v491 = constructor_put_in_xmm(ctx, v175);

10855

                                                                                            let v492 = &C::xmm_to_xmm_mem(ctx, v491);

10856

                                                                                            let v493 = constructor_x64_pmullw(ctx, v185, v492);

10857

                                                                                            let v494 = &C::xmm_to_xmm_mem(ctx, v491);

10858

                                                                                            let v515 = constructor_x64_pmulhuw(ctx, v185, v494);

10859

                                                                                            let v516 = &C::xmm_to_xmm_mem(ctx, v515);

10860

                                                                                            let v521 = constructor_x64_punpcklwd(ctx, v493, v516);

10861

                                                                                            let v522 = constructor_output_xmm(ctx, v521);

10862

                                                                                            // Rule at src/isa/x64/lower.isle line 1162.

10863

                                                                                            return Some(v522);

10864

10865

10866

10867

10868

10869

10870

10871

10872

10873

10874

                                                    &Opcode::UwidenHigh => {

10875

                                                        let v180 = C::def_inst(ctx, v38.0);

10876

                                                        if let Some(v181) = v180 {

10877

                                                            let v182 = &C::inst_data(ctx, v181);

10878

                                                            if let &InstructionData::Unary {

10879

                                                                opcode: ref v183,

10880

                                                                arg: v184,

10881

                                                            } = v182

10882

10883

                                                                if let &Opcode::UwidenHigh = v183 {

10884

                                                                    let v481 =

10885

                                                                        C::value_type(ctx, v184);

10886

                                                                    let v482 =

10887

                                                                        C::multi_lane(ctx, v481);

10888

                                                                    if let Some(v483) = v482 {

10889

                                                                        if v483.0 == 0x10 {

10890

                                                                            if v483.1 == 0x8 {

10891

                                                                                let v486 =

10892

                                                                                    C::value_type(

10893

                                                                                        ctx, v175,

10894

);

10895

                                                                                let v487 =

10896

                                                                                    C::multi_lane(

10897

                                                                                        ctx, v486,

10898

);

10899

                                                                                if let Some(v488) =

10900

                                                                                    v487

10901

10902

                                                                                    if v488.0

10903

                                                                                        == 0x10

10904

10905

                                                                                        if v488.1

10906

                                                                                            == 0x8

10907

10908

                                                                                            let v185 = constructor_put_in_xmm(ctx, v184);

10909

                                                                                            let v491 = constructor_put_in_xmm(ctx, v175);

10910

                                                                                            let v492 = &C::xmm_to_xmm_mem(ctx, v491);

10911

                                                                                            let v493 = constructor_x64_pmullw(ctx, v185, v492);

10912

                                                                                            let v494 = &C::xmm_to_xmm_mem(ctx, v491);

10913

                                                                                            let v515 = constructor_x64_pmulhuw(ctx, v185, v494);

10914

                                                                                            let v516 = &C::xmm_to_xmm_mem(ctx, v515);

10915

                                                                                            let v517 = constructor_x64_punpckhwd(ctx, v493, v516);

10916

                                                                                            let v518 = constructor_output_xmm(ctx, v517);

10917

                                                                                            // Rule at src/isa/x64/lower.isle line 1140.

10918

                                                                                            return Some(v518);

10919

10920

10921

10922

10923

10924

10925

10926

10927

10928

10929

                                                    _ => {}

10930

10931

10932

10933

                                        let v441 = C::use_sse41(ctx);

10934

                                        if v441 == true {

10935

                                            let v68 = constructor_put_in_xmm(ctx, v38.0);

10936

                                            let v69 = &C::put_in_xmm_mem(ctx, v38.1);

10937

                                            let v442 = constructor_x64_pmulld(ctx, v68, v69);

10938

                                            let v443 = constructor_output_xmm(ctx, v442);

10939

                                            // Rule at src/isa/x64/lower.isle line 1027.

10940

                                            return Some(v443);

10941

10942

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

10943

                                        let v444 = constructor_put_in_xmm(ctx, v38.1);

10944

                                        let v316 = &C::xmm_to_xmm_mem(ctx, v68);

10945

                                        let v446 = constructor_x64_pshufd(ctx, v316, 0x31);

10946

                                        let v447 = &C::xmm_to_xmm_mem(ctx, v444);

10947

                                        let v448 = constructor_x64_pshufd(ctx, v447, 0x31);

10948

                                        let v449 = &C::xmm_to_xmm_mem(ctx, v444);

10949

                                        let v450 = constructor_x64_pmuludq(ctx, v68, v449);

10950

                                        let v451 = &C::xmm_to_xmm_mem(ctx, v450);

10951

                                        let v453 = constructor_x64_pshufd(ctx, v451, 0x8);

10952

                                        let v454 = &C::xmm_to_xmm_mem(ctx, v448);

10953

                                        let v455 = constructor_x64_pmuludq(ctx, v446, v454);

10954

                                        let v456 = &C::xmm_to_xmm_mem(ctx, v455);

10955

                                        let v457 = constructor_x64_pshufd(ctx, v456, 0x8);

10956

                                        let v458 = &C::xmm_to_xmm_mem(ctx, v457);

10957

                                        let v459 = constructor_x64_punpckldq(ctx, v453, v458);

10958

                                        let v460 = constructor_output_xmm(ctx, v459);

10959

                                        // Rule at src/isa/x64/lower.isle line 1034.

10960

                                        return Some(v460);

10961

10962

10963

                                0x40 => {

10964

                                    if v65.1 == 0x2 {

10965

                                        let v38 = C::unpack_value_array_2(ctx, v37);

10966

                                        let v171 = C::def_inst(ctx, v38.1);

10967

                                        if let Some(v172) = v171 {

10968

                                            let v173 = &C::inst_data(ctx, v172);

10969

                                            if let &InstructionData::Unary {

10970

                                                opcode: ref v174,

10971

                                                arg: v175,

10972

                                            } = v173

10973

10974

                                                match v174 {

10975

                                                    &Opcode::SwidenLow => {

10976

                                                        let v180 = C::def_inst(ctx, v38.0);

10977

                                                        if let Some(v181) = v180 {

10978

                                                            let v182 = &C::inst_data(ctx, v181);

10979

                                                            if let &InstructionData::Unary {

10980

                                                                opcode: ref v183,

10981

                                                                arg: v184,

10982

                                                            } = v182

10983

10984

                                                                if let &Opcode::SwidenLow = v183 {

10985

                                                                    let v441 = C::use_sse41(ctx);

10986

                                                                    if v441 == true {

10987

                                                                        let v481 = C::value_type(

10988

                                                                            ctx, v184,

10989

);

10990

                                                                        let v482 = C::multi_lane(

10991

                                                                            ctx, v481,

10992

);

10993

                                                                        if let Some(v483) = v482 {

10994

                                                                            if v483.0 == 0x20 {

10995

                                                                                if v483.1 == 0x4 {

10996

                                                                                    let v486 = C::value_type(ctx, v175);

10997

                                                                                    let v487 = C::multi_lane(ctx, v486);

10998

                                                                                    if let Some(

10999

                                                                                        v488,

11000

                                                                                    ) = v487

11001

11002

                                                                                        if v488.0

11003

                                                                                            == 0x20

11004

11005

                                                                                            if v488.1 == 0x4 {

11006

                                                                                                let v499 = &C::put_in_xmm_mem(ctx, v184);

11007

                                                                                                let v510 = constructor_x64_pshufd(ctx, v499, 0x50);

11008

                                                                                                let v502 = &C::put_in_xmm_mem(ctx, v175);

11009

                                                                                                let v511 = constructor_x64_pshufd(ctx, v502, 0x50);

11010

                                                                                                let v512 = &C::xmm_to_xmm_mem(ctx, v511);

11011

                                                                                                let v513 = constructor_x64_pmuldq(ctx, v510, v512);

11012

                                                                                                let v514 = constructor_output_xmm(ctx, v513);

11013

                                                                                                // Rule at src/isa/x64/lower.isle line 1129.

11014

                                                                                                return Some(v514);

11015

11016

11017

11018

11019

11020

11021

11022

11023

11024

11025

11026

                                                    &Opcode::SwidenHigh => {

11027

                                                        let v180 = C::def_inst(ctx, v38.0);

11028

                                                        if let Some(v181) = v180 {

11029

                                                            let v182 = &C::inst_data(ctx, v181);

11030

                                                            if let &InstructionData::Unary {

11031

                                                                opcode: ref v183,

11032

                                                                arg: v184,

11033

                                                            } = v182

11034

11035

                                                                if let &Opcode::SwidenHigh = v183 {

11036

                                                                    let v441 = C::use_sse41(ctx);

11037

                                                                    if v441 == true {

11038

                                                                        let v481 = C::value_type(

11039

                                                                            ctx, v184,

11040

);

11041

                                                                        let v482 = C::multi_lane(

11042

                                                                            ctx, v481,

11043

);

11044

                                                                        if let Some(v483) = v482 {

11045

                                                                            if v483.0 == 0x20 {

11046

                                                                                if v483.1 == 0x4 {

11047

                                                                                    let v486 = C::value_type(ctx, v175);

11048

                                                                                    let v487 = C::multi_lane(ctx, v486);

11049

                                                                                    if let Some(

11050

                                                                                        v488,

11051

                                                                                    ) = v487

11052

11053

                                                                                        if v488.0

11054

                                                                                            == 0x20

11055

11056

                                                                                            if v488.1 == 0x4 {

11057

                                                                                                let v499 = &C::put_in_xmm_mem(ctx, v184);

11058

                                                                                                let v501 = constructor_x64_pshufd(ctx, v499, 0xFA);

11059

                                                                                                let v502 = &C::put_in_xmm_mem(ctx, v175);

11060

                                                                                                let v503 = constructor_x64_pshufd(ctx, v502, 0xFA);

11061

                                                                                                let v504 = &C::xmm_to_xmm_mem(ctx, v503);

11062

                                                                                                let v505 = constructor_x64_pmuldq(ctx, v501, v504);

11063

                                                                                                let v506 = constructor_output_xmm(ctx, v505);

11064

                                                                                                // Rule at src/isa/x64/lower.isle line 1106.

11065

                                                                                                return Some(v506);

11066

11067

11068

11069

11070

11071

11072

11073

11074

11075

11076

11077

                                                    &Opcode::UwidenLow => {

11078

                                                        let v180 = C::def_inst(ctx, v38.0);

11079

                                                        if let Some(v181) = v180 {

11080

                                                            let v182 = &C::inst_data(ctx, v181);

11081

                                                            if let &InstructionData::Unary {

11082

                                                                opcode: ref v183,

11083

                                                                arg: v184,

11084

                                                            } = v182

11085

11086

                                                                if let &Opcode::UwidenLow = v183 {

11087

                                                                    let v481 =

11088

                                                                        C::value_type(ctx, v184);

11089

                                                                    let v482 =

11090

                                                                        C::multi_lane(ctx, v481);

11091

                                                                    if let Some(v483) = v482 {

11092

                                                                        if v483.0 == 0x20 {

11093

                                                                            if v483.1 == 0x4 {

11094

                                                                                let v486 =

11095

                                                                                    C::value_type(

11096

                                                                                        ctx, v175,

11097

);

11098

                                                                                let v487 =

11099

                                                                                    C::multi_lane(

11100

                                                                                        ctx, v486,

11101

);

11102

                                                                                if let Some(v488) =

11103

                                                                                    v487

11104

11105

                                                                                    if v488.0

11106

                                                                                        == 0x20

11107

11108

                                                                                        if v488.1

11109

                                                                                            == 0x4

11110

11111

                                                                                            let v499 = &C::put_in_xmm_mem(ctx, v184);

11112

                                                                                            let v510 = constructor_x64_pshufd(ctx, v499, 0x50);

11113

                                                                                            let v502 = &C::put_in_xmm_mem(ctx, v175);

11114

                                                                                            let v511 = constructor_x64_pshufd(ctx, v502, 0x50);

11115

                                                                                            let v512 = &C::xmm_to_xmm_mem(ctx, v511);

11116

                                                                                            let v523 = constructor_x64_pmuludq(ctx, v510, v512);

11117

                                                                                            let v524 = constructor_output_xmm(ctx, v523);

11118

                                                                                            // Rule at src/isa/x64/lower.isle line 1174.

11119

                                                                                            return Some(v524);

11120

11121

11122

11123

11124

11125

11126

11127

11128

11129

11130

                                                    &Opcode::UwidenHigh => {

11131

                                                        let v180 = C::def_inst(ctx, v38.0);

11132

                                                        if let Some(v181) = v180 {

11133

                                                            let v182 = &C::inst_data(ctx, v181);

11134

                                                            if let &InstructionData::Unary {

11135

                                                                opcode: ref v183,

11136

                                                                arg: v184,

11137

                                                            } = v182

11138

11139

                                                                if let &Opcode::UwidenHigh = v183 {

11140

                                                                    let v481 =

11141

                                                                        C::value_type(ctx, v184);

11142

                                                                    let v482 =

11143

                                                                        C::multi_lane(ctx, v481);

11144

                                                                    if let Some(v483) = v482 {

11145

                                                                        if v483.0 == 0x20 {

11146

                                                                            if v483.1 == 0x4 {

11147

                                                                                let v486 =

11148

                                                                                    C::value_type(

11149

                                                                                        ctx, v175,

11150

);

11151

                                                                                let v487 =

11152

                                                                                    C::multi_lane(

11153

                                                                                        ctx, v486,

11154

);

11155

                                                                                if let Some(v488) =

11156

                                                                                    v487

11157

11158

                                                                                    if v488.0

11159

                                                                                        == 0x20

11160

11161

                                                                                        if v488.1

11162

                                                                                            == 0x4

11163

11164

                                                                                            let v499 = &C::put_in_xmm_mem(ctx, v184);

11165

                                                                                            let v501 = constructor_x64_pshufd(ctx, v499, 0xFA);

11166

                                                                                            let v502 = &C::put_in_xmm_mem(ctx, v175);

11167

                                                                                            let v503 = constructor_x64_pshufd(ctx, v502, 0xFA);

11168

                                                                                            let v504 = &C::xmm_to_xmm_mem(ctx, v503);

11169

                                                                                            let v519 = constructor_x64_pmuludq(ctx, v501, v504);

11170

                                                                                            let v520 = constructor_output_xmm(ctx, v519);

11171

                                                                                            // Rule at src/isa/x64/lower.isle line 1152.

11172

                                                                                            return Some(v520);

11173

11174

11175

11176

11177

11178

11179

11180

11181

11182

11183

                                                    _ => {}

11184

11185

11186

11187

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

11188

                                        let v444 = constructor_put_in_xmm(ctx, v38.1);

11189

                                        let v465 = &C::xmi_imm(ctx, 0x20);

11190

                                        let v466 = constructor_x64_psrlq(ctx, v68, v465);

11191

                                        let v447 = &C::xmm_to_xmm_mem(ctx, v444);

11192

                                        let v467 = constructor_x64_pmuludq(ctx, v466, v447);

11193

                                        let v468 = &C::xmi_imm(ctx, 0x20);

11194

                                        let v469 = constructor_x64_psrlq(ctx, v444, v468);

11195

                                        let v470 = &C::xmm_to_xmm_mem(ctx, v469);

11196

                                        let v471 = constructor_x64_pmuludq(ctx, v68, v470);

11197

                                        let v472 = &C::xmm_to_xmm_mem(ctx, v471);

11198

                                        let v473 = constructor_x64_paddq(ctx, v467, v472);

11199

                                        let v474 = &C::xmi_imm(ctx, 0x20);

11200

                                        let v475 = constructor_x64_psllq(ctx, v473, v474);

11201

                                        let v476 = &C::xmm_to_xmm_mem(ctx, v444);

11202

                                        let v477 = constructor_x64_pmuludq(ctx, v68, v476);

11203

                                        let v478 = &C::xmm_to_xmm_mem(ctx, v475);

11204

                                        let v479 = constructor_x64_paddq(ctx, v477, v478);

11205

                                        let v480 = constructor_output_xmm(ctx, v479);

11206

                                        // Rule at src/isa/x64/lower.isle line 1072.

11207

                                        return Some(v480);

11208

11209

11210

                                _ => {}

11211

11212

11213

                        let v4 = C::fits_in_64(ctx, v3);

11214

                        if let Some(v5) = v4 {

11215

                            let v38 = C::unpack_value_array_2(ctx, v37);

11216

                            let v58 = &C::sinkable_load(ctx, v38.0);

11217

                            if let Some(v59) = v58 {

11218

                                let v60 = constructor_put_in_gpr(ctx, v38.1);

11219

                                let v61 = &constructor_sink_load_to_gpr_mem_imm(ctx, v59);

11220

                                let v423 = constructor_x64_mul(ctx, v5, v60, v61);

11221

                                let v424 = constructor_output_gpr(ctx, v423);

11222

                                // Rule at src/isa/x64/lower.isle line 978.

11223

                                return Some(v424);

11224

11225

                            let v158 = &C::simm32_from_value(ctx, v38.0);

11226

                            if let Some(v159) = v158 {

11227

                                let v60 = constructor_put_in_gpr(ctx, v38.1);

11228

                                let v421 = constructor_x64_mul(ctx, v5, v60, v159);

11229

                                let v422 = constructor_output_gpr(ctx, v421);

11230

                                // Rule at src/isa/x64/lower.isle line 975.

11231

                                return Some(v422);

11232

11233

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

11234

                            let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);

11235

                            let v419 = constructor_x64_mul(ctx, v5, v41, v42);

11236

                            let v420 = constructor_output_gpr(ctx, v419);

11237

                            // Rule at src/isa/x64/lower.isle line 969.

11238

                            return Some(v420);

11239

11240

11241

11242

                &Opcode::Umulhi => {

11243

                    let v38 = C::unpack_value_array_2(ctx, v37);

11244

                    let v2080 = C::value_type(ctx, v38.0);

11245

                    match v2080 {

11246

                        I16 => {

11247

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

11248

                            let v109 = &constructor_put_in_gpr_mem(ctx, v38.1);

11249

                            let v2220 = constructor_mul_hi(ctx, I16, false, v41, v109);

11250

                            let v2221 = constructor_value_regs_get_gpr(ctx, v2220, 0x1);

11251

                            let v2222 = constructor_output_gpr(ctx, v2221);

11252

                            // Rule at src/isa/x64/lower.isle line 4138.

11253

                            return Some(v2222);

11254

11255

                        I32 => {

11256

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

11257

                            let v109 = &constructor_put_in_gpr_mem(ctx, v38.1);

11258

                            let v2223 = constructor_mul_hi(ctx, I32, false, v41, v109);

11259

                            let v2224 = constructor_value_regs_get_gpr(ctx, v2223, 0x1);

11260

                            let v2225 = constructor_output_gpr(ctx, v2224);

11261

                            // Rule at src/isa/x64/lower.isle line 4143.

11262

                            return Some(v2225);

11263

11264

                        I64 => {

11265

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

11266

                            let v109 = &constructor_put_in_gpr_mem(ctx, v38.1);

11267

                            let v2226 = constructor_mul_hi(ctx, I64, false, v41, v109);

11268

                            let v2227 = constructor_value_regs_get_gpr(ctx, v2226, 0x1);

11269

                            let v2228 = constructor_output_gpr(ctx, v2227);

11270

                            // Rule at src/isa/x64/lower.isle line 4148.

11271

                            return Some(v2228);

11272

11273

                        _ => {}

11274

11275

11276

                &Opcode::Smulhi => {

11277

                    let v38 = C::unpack_value_array_2(ctx, v37);

11278

                    let v2080 = C::value_type(ctx, v38.0);

11279

                    match v2080 {

11280

                        I16 => {

11281

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

11282

                            let v109 = &constructor_put_in_gpr_mem(ctx, v38.1);

11283

                            let v2229 = constructor_mul_hi(ctx, I16, true, v41, v109);

11284

                            let v2230 = constructor_value_regs_get_gpr(ctx, v2229, 0x1);

11285

                            let v2231 = constructor_output_gpr(ctx, v2230);

11286

                            // Rule at src/isa/x64/lower.isle line 4155.

11287

                            return Some(v2231);

11288

11289

                        I32 => {

11290

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

11291

                            let v109 = &constructor_put_in_gpr_mem(ctx, v38.1);

11292

                            let v2232 = constructor_mul_hi(ctx, I32, true, v41, v109);

11293

                            let v2233 = constructor_value_regs_get_gpr(ctx, v2232, 0x1);

11294

                            let v2234 = constructor_output_gpr(ctx, v2233);

11295

                            // Rule at src/isa/x64/lower.isle line 4160.

11296

                            return Some(v2234);

11297

11298

                        I64 => {

11299

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

11300

                            let v109 = &constructor_put_in_gpr_mem(ctx, v38.1);

11301

                            let v2235 = constructor_mul_hi(ctx, I64, true, v41, v109);

11302

                            let v2236 = constructor_value_regs_get_gpr(ctx, v2235, 0x1);

11303

                            let v2237 = constructor_output_gpr(ctx, v2236);

11304

                            // Rule at src/isa/x64/lower.isle line 4165.

11305

                            return Some(v2237);

11306

11307

                        _ => {}

11308

11309

11310

                &Opcode::SqmulRoundSat => {

11311

                    let v38 = C::unpack_value_array_2(ctx, v37);

11312

                    let v2080 = C::value_type(ctx, v38.0);

11313

                    if v2080 == I16X8 {

11314

                        let v525 = C::use_ssse3(ctx);

11315

                        if v525 == true {

11316

                            let v68 = constructor_put_in_xmm(ctx, v38.0);

11317

                            let v444 = constructor_put_in_xmm(ctx, v38.1);

11318

                            let v2544 =

11319

                                C::emit_u128_le_const(ctx, 0x80008000800080008000800080008000);

11320

                            let v2545 = &constructor_const_to_xmm_mem(ctx, v2544);

11321

                            let v447 = &C::xmm_to_xmm_mem(ctx, v444);

11322

                            let v2546 = constructor_x64_pmulhrsw(ctx, v68, v447);

11323

                            let v2547 = constructor_x64_pcmpeqw(ctx, v2546, v2545);

11324

                            let v2548 = &C::xmm_to_xmm_mem(ctx, v2547);

11325

                            let v2549 = constructor_x64_pxor(ctx, v2546, v2548);

11326

                            let v2550 = constructor_output_xmm(ctx, v2549);

11327

                            // Rule at src/isa/x64/lower.isle line 4631.

11328

                            return Some(v2550);

11329

11330

                        let v68 = constructor_put_in_xmm(ctx, v38.0);

11331

                        let v444 = constructor_put_in_xmm(ctx, v38.1);

11332

                        let v1963 = &C::xmm_to_xmm_mem(ctx, v444);

11333

                        let v2551 = constructor_x64_pmullw(ctx, v68, v1963);

11334

                        let v447 = &C::xmm_to_xmm_mem(ctx, v444);

11335

                        let v2552 = constructor_x64_pmulhw(ctx, v68, v447);

11336

                        let v2553 = &C::xmm_to_xmm_mem(ctx, v2552);

11337

                        let v2554 = constructor_x64_punpcklwd(ctx, v2551, v2553);

11338

                        let v2555 = &C::xmm_to_xmm_mem(ctx, v2552);

11339

                        let v2556 = constructor_x64_punpckhwd(ctx, v2551, v2555);

11340

                        let v2558 = C::emit_u128_le_const(ctx, 0x4000000040000000400000004000);

11341

                        let v2559 = &constructor_const_to_xmm_mem(ctx, v2558);

11342

                        let v2560 = constructor_x64_movdqu_load(ctx, v2559);

11343

                        let v2561 = &C::xmm_to_xmm_mem(ctx, v2560);

11344

                        let v2562 = constructor_x64_paddd(ctx, v2554, v2561);

11345

                        let v2563 = &C::xmm_to_xmm_mem(ctx, v2560);

11346

                        let v2564 = constructor_x64_paddd(ctx, v2556, v2563);

11347

                        let v2566 = &C::xmi_imm(ctx, 0xF);

11348

                        let v2567 = constructor_x64_psrad(ctx, v2562, v2566);

11349

                        let v2568 = &C::xmi_imm(ctx, 0xF);

11350

                        let v2569 = constructor_x64_psrad(ctx, v2564, v2568);

11351

                        let v2570 = &C::xmm_to_xmm_mem(ctx, v2569);

11352

                        let v2571 = constructor_x64_packssdw(ctx, v2567, v2570);

11353

                        let v2572 = constructor_output_xmm(ctx, v2571);

11354

                        // Rule at src/isa/x64/lower.isle line 4647.

11355

                        return Some(v2572);

11356

11357

11358

                &Opcode::X86Pmulhrsw => {

11359

                    let v525 = C::use_ssse3(ctx);

11360

                    if v525 == true {

11361

                        let v38 = C::unpack_value_array_2(ctx, v37);

11362

                        let v2080 = C::value_type(ctx, v38.0);

11363

                        if v2080 == I16X8 {

11364

                            let v68 = constructor_put_in_xmm(ctx, v38.0);

11365

                            let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11366

                            let v2573 = constructor_x64_pmulhrsw(ctx, v68, v69);

11367

                            let v2574 = constructor_output_xmm(ctx, v2573);

11368

                            // Rule at src/isa/x64/lower.isle line 4673.

11369

                            return Some(v2574);

11370

11371

11372

11373

                &Opcode::Udiv => {

11374

                    let v38 = C::unpack_value_array_2(ctx, v37);

11375

                    let v2080 = C::value_type(ctx, v38.0);

11376

                    if v2080 == I8 {

11377

                        let v2164 = constructor_extend_to_gpr(ctx, v38.0, I32, &ExtendKind::Zero);

11378

                        let v356 = constructor_put_in_gpr(ctx, v38.1);

11379

                        let v2165 = &C::gpr_to_gpr_mem(ctx, v356);

11380

                        let v2168 = constructor_x64_div8(

11381

                            ctx,

11382

                            v2164,

11383

                            v2165,

11384

                            &DivSignedness::Unsigned,

11385

                            &TrapCode::IntegerDivisionByZero,

11386

);

11387

                        let v2169 = constructor_output_gpr(ctx, v2168);

11388

                        // Rule at src/isa/x64/lower.isle line 4017.

11389

                        return Some(v2169);

11390

11391

                    let v2170 = C::fits_in_64(ctx, v2080);

11392

                    if let Some(v2171) = v2170 {

11393

                        let v41 = constructor_put_in_gpr(ctx, v38.0);

11394

                        let v15 = constructor_imm(ctx, I64, 0x0);

11395

                        let v2172 = C::gpr_new(ctx, v15);

11396

                        let v2173 = constructor_put_in_gpr(ctx, v38.1);

11397

                        let v2174 = &C::gpr_to_gpr_mem(ctx, v2173);

11398

                        let v2175 = &C::raw_operand_size_of_type(ctx, v2171);

11399

                        let v2176 = constructor_x64_div_quotient(

11400

                            ctx,

11401

                            v41,

11402

                            v2172,

11403

                            v2174,

11404

                            v2175,

11405

                            &DivSignedness::Unsigned,

11406

                            &TrapCode::IntegerDivisionByZero,

11407

);

11408

                        let v2177 = C::output(ctx, v2176);

11409

                        // Rule at src/isa/x64/lower.isle line 4026.

11410

                        return Some(v2177);

11411

11412

11413

                &Opcode::Sdiv => {

11414

                    let v38 = C::unpack_value_array_2(ctx, v37);

11415

                    let v2080 = C::value_type(ctx, v38.0);

11416

                    if v2080 == I8 {

11417

                        let v41 = constructor_put_in_gpr(ctx, v38.0);

11418

                        let v2179 = constructor_x64_sign_extend_data(ctx, v41, &OperandSize::Size8);

11419

                        let v2180 = constructor_nonzero_sdiv_divisor(ctx, I8, v38.1);

11420

                        let v2181 = &C::reg_to_gpr_mem(ctx, v2180);

11421

                        let v2184 = constructor_x64_div8(

11422

                            ctx,

11423

                            v2179,

11424

                            v2181,

11425

                            &DivSignedness::Signed,

11426

                            &TrapCode::IntegerOverflow,

11427

);

11428

                        let v2185 = constructor_output_gpr(ctx, v2184);

11429

                        // Rule at src/isa/x64/lower.isle line 4036.

11430

                        return Some(v2185);

11431

11432

                    let v2170 = C::fits_in_64(ctx, v2080);

11433

                    if let Some(v2171) = v2170 {

11434

                        let v41 = constructor_put_in_gpr(ctx, v38.0);

11435

                        let v2186 = &C::raw_operand_size_of_type(ctx, v2171);

11436

                        let v2187 = constructor_x64_sign_extend_data(ctx, v41, v2186);

11437

                        let v2188 = constructor_nonzero_sdiv_divisor(ctx, v2171, v38.1);

11438

                        let v2189 = &C::reg_to_gpr_mem(ctx, v2188);

11439

                        let v2190 = constructor_x64_div_quotient(

11440

                            ctx,

11441

                            v41,

11442

                            v2187,

11443

                            v2189,

11444

                            v2186,

11445

                            &DivSignedness::Signed,

11446

                            &TrapCode::IntegerOverflow,

11447

);

11448

                        let v2191 = C::output(ctx, v2190);

11449

                        // Rule at src/isa/x64/lower.isle line 4042.

11450

                        return Some(v2191);

11451

11452

11453

                &Opcode::Urem => {

11454

                    let v38 = C::unpack_value_array_2(ctx, v37);

11455

                    let v2080 = C::value_type(ctx, v38.0);

11456

                    if v2080 == I8 {

11457

                        let v2164 = constructor_extend_to_gpr(ctx, v38.0, I32, &ExtendKind::Zero);

11458

                        let v356 = constructor_put_in_gpr(ctx, v38.1);

11459

                        let v2165 = &C::gpr_to_gpr_mem(ctx, v356);

11460

                        let v2168 = constructor_x64_div8(

11461

                            ctx,

11462

                            v2164,

11463

                            v2165,

11464

                            &DivSignedness::Unsigned,

11465

                            &TrapCode::IntegerDivisionByZero,

11466

);

11467

                        let v1204 = Imm8Reg::Imm8 { imm: 0x8 };

11468

                        let v2192 = &C::imm8_reg_to_imm8_gpr(ctx, &v1204);

11469

                        let v2193 = constructor_x64_shr(ctx, I64, v2168, v2192);

11470

                        let v2194 = constructor_output_gpr(ctx, v2193);

11471

                        // Rule at src/isa/x64/lower.isle line 4075.

11472

                        return Some(v2194);

11473

11474

                    let v2170 = C::fits_in_64(ctx, v2080);

11475

                    if let Some(v2171) = v2170 {

11476

                        let v41 = constructor_put_in_gpr(ctx, v38.0);

11477

                        let v15 = constructor_imm(ctx, I64, 0x0);

11478

                        let v2172 = C::gpr_new(ctx, v15);

11479

                        let v2173 = constructor_put_in_gpr(ctx, v38.1);

11480

                        let v2174 = &C::gpr_to_gpr_mem(ctx, v2173);

11481

                        let v2175 = &C::raw_operand_size_of_type(ctx, v2171);

11482

                        let v2195 = constructor_x64_div_remainder(

11483

                            ctx,

11484

                            v41,

11485

                            v2172,

11486

                            v2174,

11487

                            v2175,

11488

                            &DivSignedness::Unsigned,

11489

                            &TrapCode::IntegerDivisionByZero,

11490

);

11491

                        let v2196 = C::output(ctx, v2195);

11492

                        // Rule at src/isa/x64/lower.isle line 4084.

11493

                        return Some(v2196);

11494

11495

11496

                &Opcode::Srem => {

11497

                    let v38 = C::unpack_value_array_2(ctx, v37);

11498

                    let v171 = C::def_inst(ctx, v38.1);

11499

                    if let Some(v172) = v171 {

11500

                        let v173 = &C::inst_data(ctx, v172);

11501

                        if let &InstructionData::UnaryImm {

11502

                            opcode: ref v330,

11503

                            imm: v331,

11504

                        } = v173

11505

11506

                            if let &Opcode::Iconst = v330 {

11507

                                let v2080 = C::value_type(ctx, v38.0);

11508

                                if v2080 == I8 {

11509

                                    let v2197 = C::safe_divisor_from_imm64(ctx, I8, v331);

11510

                                    if let Some(v2198) = v2197 {

11511

                                        let v41 = constructor_put_in_gpr(ctx, v38.0);

11512

                                        let v2179 = constructor_x64_sign_extend_data(

11513

                                            ctx,

11514

                                            v41,

11515

                                            &OperandSize::Size8,

11516

);

11517

                                        let v2199 = constructor_imm(ctx, I8, v2198);

11518

                                        let v2200 = &C::reg_to_gpr_mem(ctx, v2199);

11519

                                        let v2201 = constructor_x64_div8(

11520

                                            ctx,

11521

                                            v2179,

11522

                                            v2200,

11523

                                            &DivSignedness::Signed,

11524

                                            &TrapCode::IntegerDivisionByZero,

11525

);

11526

                                        let v1204 = Imm8Reg::Imm8 { imm: 0x8 };

11527

                                        let v2202 = &C::imm8_reg_to_imm8_gpr(ctx, &v1204);

11528

                                        let v2203 = constructor_x64_shr(ctx, I64, v2201, v2202);

11529

                                        let v2204 = constructor_output_gpr(ctx, v2203);

11530

                                        // Rule at src/isa/x64/lower.isle line 4099.

11531

                                        return Some(v2204);

11532

11533

11534

                                let v2205 = C::safe_divisor_from_imm64(ctx, v2080, v331);

11535

                                if let Some(v2206) = v2205 {

11536

                                    let v41 = constructor_put_in_gpr(ctx, v38.0);

11537

                                    let v2207 = &C::raw_operand_size_of_type(ctx, v2080);

11538

                                    let v2208 = constructor_x64_sign_extend_data(ctx, v41, v2207);

11539

                                    let v2209 = constructor_imm(ctx, v2080, v2206);

11540

                                    let v2210 = &C::reg_to_gpr_mem(ctx, v2209);

11541

                                    let v2211 = constructor_x64_div_remainder(

11542

                                        ctx,

11543

                                        v41,

11544

                                        v2208,

11545

                                        v2210,

11546

                                        v2207,

11547

                                        &DivSignedness::Signed,

11548

                                        &TrapCode::IntegerDivisionByZero,

11549

);

11550

                                    let v2212 = C::output(ctx, v2211);

11551

                                    // Rule at src/isa/x64/lower.isle line 4108.

11552

                                    return Some(v2212);

11553

11554

11555

11556

11557

                    let v2080 = C::value_type(ctx, v38.0);

11558

                    if v2080 == I8 {

11559

                        let v41 = constructor_put_in_gpr(ctx, v38.0);

11560

                        let v2179 = constructor_x64_sign_extend_data(ctx, v41, &OperandSize::Size8);

11561

                        let v2213 = constructor_put_in_gpr(ctx, v38.1);

11562

                        let v2214 = constructor_x64_checked_srem_seq8(ctx, v2179, v2213);

11563

                        let v1204 = Imm8Reg::Imm8 { imm: 0x8 };

11564

                        let v2192 = &C::imm8_reg_to_imm8_gpr(ctx, &v1204);

11565

                        let v2215 = constructor_x64_shr(ctx, I64, v2214, v2192);

11566

                        let v2216 = constructor_output_gpr(ctx, v2215);

11567

                        // Rule at src/isa/x64/lower.isle line 4121.

11568

                        return Some(v2216);

11569

11570

                    let v41 = constructor_put_in_gpr(ctx, v38.0);

11571

                    let v2207 = &C::raw_operand_size_of_type(ctx, v2080);

11572

                    let v2208 = constructor_x64_sign_extend_data(ctx, v41, v2207);

11573

                    let v2173 = constructor_put_in_gpr(ctx, v38.1);

11574

                    let v2217 = constructor_x64_checked_srem_seq(ctx, v2207, v41, v2208, v2173);

11575

                    let v2218 = C::value_regs_get(ctx, v2217, 0x1);

11576

                    let v2219 = constructor_output_reg(ctx, v2218);

11577

                    // Rule at src/isa/x64/lower.isle line 4127.

11578

                    return Some(v2219);

11579

11580

                &Opcode::UaddOverflow => {

11581

                    let v38 = C::unpack_value_array_2(ctx, v37);

11582

                    let v92 = C::value_type(ctx, v38.1);

11583

                    let v93 = C::fits_in_64(ctx, v92);

11584

                    if let Some(v94) = v93 {

11585

                        let v41 = constructor_put_in_gpr(ctx, v38.0);

11586

                        let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);

11587

                        let v97 = constructor_construct_overflow_op_alu(

11588

                            ctx,

11589

                            v94,

11590

                            &CC::B,

11591

                            &AluRmiROpcode::Add,

11592

                            v41,

11593

                            v42,

11594

);

11595

                        // Rule at src/isa/x64/lower.isle line 137.

11596

                        return Some(v97);

11597

11598

                    if v92 == I128 {

11599

                        let v99 = constructor_construct_overflow_op_alu_128(

11600

                            ctx,

11601

                            &CC::B,

11602

                            &AluRmiROpcode::Add,

11603

                            &AluRmiROpcode::Adc,

11604

                            v38.0,

11605

                            v38.1,

11606

);

11607

                        // Rule at src/isa/x64/lower.isle line 141.

11608

                        return Some(v99);

11609

11610

11611

                &Opcode::SaddOverflow => {

11612

                    let v38 = C::unpack_value_array_2(ctx, v37);

11613

                    let v92 = C::value_type(ctx, v38.1);

11614

                    let v93 = C::fits_in_64(ctx, v92);

11615

                    if let Some(v94) = v93 {

11616

                        let v41 = constructor_put_in_gpr(ctx, v38.0);

11617

                        let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);

11618

                        let v101 = constructor_construct_overflow_op_alu(

11619

                            ctx,

11620

                            v94,

11621

                            &CC::O,

11622

                            &AluRmiROpcode::Add,

11623

                            v41,

11624

                            v42,

11625

);

11626

                        // Rule at src/isa/x64/lower.isle line 146.

11627

                        return Some(v101);

11628

11629

                    if v92 == I128 {

11630

                        let v102 = constructor_construct_overflow_op_alu_128(

11631

                            ctx,

11632

                            &CC::O,

11633

                            &AluRmiROpcode::Add,

11634

                            &AluRmiROpcode::Adc,

11635

                            v38.0,

11636

                            v38.1,

11637

);

11638

                        // Rule at src/isa/x64/lower.isle line 149.

11639

                        return Some(v102);

11640

11641

11642

                &Opcode::UsubOverflow => {

11643

                    let v38 = C::unpack_value_array_2(ctx, v37);

11644

                    let v92 = C::value_type(ctx, v38.1);

11645

                    let v93 = C::fits_in_64(ctx, v92);

11646

                    if let Some(v94) = v93 {

11647

                        let v41 = constructor_put_in_gpr(ctx, v38.0);

11648

                        let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);

11649

                        let v104 = constructor_construct_overflow_op_alu(

11650

                            ctx,

11651

                            v94,

11652

                            &CC::B,

11653

                            &AluRmiROpcode::Sub,

11654

                            v41,

11655

                            v42,

11656

);

11657

                        // Rule at src/isa/x64/lower.isle line 154.

11658

                        return Some(v104);

11659

11660

                    if v92 == I128 {

11661

                        let v106 = constructor_construct_overflow_op_alu_128(

11662

                            ctx,

11663

                            &CC::B,

11664

                            &AluRmiROpcode::Sub,

11665

                            &AluRmiROpcode::Sbb,

11666

                            v38.0,

11667

                            v38.1,

11668

);

11669

                        // Rule at src/isa/x64/lower.isle line 157.

11670

                        return Some(v106);

11671

11672

11673

                &Opcode::SsubOverflow => {

11674

                    let v38 = C::unpack_value_array_2(ctx, v37);

11675

                    let v92 = C::value_type(ctx, v38.1);

11676

                    let v93 = C::fits_in_64(ctx, v92);

11677

                    if let Some(v94) = v93 {

11678

                        let v41 = constructor_put_in_gpr(ctx, v38.0);

11679

                        let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);

11680

                        let v107 = constructor_construct_overflow_op_alu(

11681

                            ctx,

11682

                            v94,

11683

                            &CC::O,

11684

                            &AluRmiROpcode::Sub,

11685

                            v41,

11686

                            v42,

11687

);

11688

                        // Rule at src/isa/x64/lower.isle line 162.

11689

                        return Some(v107);

11690

11691

                    if v92 == I128 {

11692

                        let v108 = constructor_construct_overflow_op_alu_128(

11693

                            ctx,

11694

                            &CC::O,

11695

                            &AluRmiROpcode::Sub,

11696

                            &AluRmiROpcode::Sbb,

11697

                            v38.0,

11698

                            v38.1,

11699

);

11700

                        // Rule at src/isa/x64/lower.isle line 165.

11701

                        return Some(v108);

11702

11703

11704

                &Opcode::UmulOverflow => {

11705

                    let v38 = C::unpack_value_array_2(ctx, v37);

11706

                    let v92 = C::value_type(ctx, v38.1);

11707

                    let v93 = C::fits_in_64(ctx, v92);

11708

                    if let Some(v94) = v93 {

11709

                        let v41 = constructor_put_in_gpr(ctx, v38.0);

11710

                        let v109 = &constructor_put_in_gpr_mem(ctx, v38.1);

11711

                        let v110 = &constructor_x64_umullo_with_flags_paired(ctx, v94, v41, v109);

11712

                        let v111 = constructor_construct_overflow_op(ctx, &CC::O, v110);

11713

                        // Rule at src/isa/x64/lower.isle line 170.

11714

                        return Some(v111);

11715

11716

11717

                &Opcode::SmulOverflow => {

11718

                    let v38 = C::unpack_value_array_2(ctx, v37);

11719

                    let v92 = C::value_type(ctx, v38.1);

11720

                    let v112 = C::ty_int_ref_16_to_64(ctx, v92);

11721

                    if let Some(v113) = v112 {

11722

                        let v41 = constructor_put_in_gpr(ctx, v38.0);

11723

                        let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);

11724

                        let v115 = constructor_construct_overflow_op_alu(

11725

                            ctx,

11726

                            v113,

11727

                            &CC::O,

11728

                            &AluRmiROpcode::Mul,

11729

                            v41,

11730

                            v42,

11731

);

11732

                        // Rule at src/isa/x64/lower.isle line 175.

11733

                        return Some(v115);

11734

11735

                    if v92 == I8 {

11736

                        let v41 = constructor_put_in_gpr(ctx, v38.0);

11737

                        let v117 = &C::put_in_reg_mem(ctx, v38.1);

11738

                        let v118 = &constructor_reg_mem_to_reg_mem_imm(ctx, v117);

11739

                        let v119 = &C::gpr_mem_imm_new(ctx, v118);

11740

                        let v120 = &constructor_x64_alurmi_with_flags_paired(

11741

                            ctx,

11742

                            &AluRmiROpcode::Mul,

11743

I8,

11744

                            v41,

11745

                            v119,

11746

);

11747

                        let v121 = constructor_construct_overflow_op(ctx, &CC::O, v120);

11748

                        // Rule at src/isa/x64/lower.isle line 179.

11749

                        return Some(v121);

11750

11751

11752

                &Opcode::Band => {

11753

                    let v1 = C::first_result(ctx, arg0);

11754

                    if let Some(v2) = v1 {

11755

                        let v3 = C::value_type(ctx, v2);

11756

                        let v45 = C::ty_32_or_64(ctx, v3);

11757

                        if let Some(v46) = v45 {

11758

                            let v38 = C::unpack_value_array_2(ctx, v37);

11759

                            let v196 = constructor_val_minus_one(ctx, v38.1);

11760

                            if let Some(v197) = v196 {

11761

                                let v211 = C::use_bmi2(ctx);

11762

                                if v211 == true {

11763

                                    let v212 = C::def_inst(ctx, v197);

11764

                                    if let Some(v213) = v212 {

11765

                                        let v214 = &C::inst_data(ctx, v213);

11766

                                        if let &InstructionData::Binary {

11767

                                            opcode: ref v215,

11768

                                            args: ref v216,

11769

                                        } = v214

11770

11771

                                            if let &Opcode::Ishl = v215 {

11772

                                                let v217 = C::unpack_value_array_2(ctx, v216);

11773

                                                let v220 = C::def_inst(ctx, v217.0);

11774

                                                if let Some(v221) = v220 {

11775

                                                    let v222 = &C::inst_data(ctx, v221);

11776

                                                    if let &InstructionData::UnaryImm {

11777

                                                        opcode: ref v223,

11778

                                                        imm: v224,

11779

                                                    } = v222

11780

11781

                                                        if let &Opcode::Iconst = v223 {

11782

                                                            let v225 = C::u64_from_imm64(ctx, v224);

11783

                                                            if v225 == 0x1 {

11784

                                                                let v198 =

11785

                                                                    &constructor_put_in_gpr_mem(

11786

                                                                        ctx, v38.0,

11787

);

11788

                                                                let v226 = constructor_put_in_gpr(

11789

                                                                    ctx, v217.1,

11790

);

11791

                                                                let v227 = C::ty_bits(ctx, v46);

11792

                                                                let v228 = C::u8_as_u32(ctx, v227);

11793

                                                                let v230 =

11794

                                                                    C::u32_sub(ctx, v228, 0x1);

11795

                                                                let v231 =

11796

                                                                    RegMemImm::Imm { simm32: v230 };

11797

                                                                let v232 =

11798

                                                                    &C::gpr_mem_imm_new(ctx, &v231);

11799

                                                                let v233 = constructor_x64_and(

11800

                                                                    ctx, v46, v226, v232,

11801

);

11802

                                                                let v234 = constructor_x64_bzhi(

11803

                                                                    ctx, v46, v198, v233,

11804

);

11805

                                                                let v235 = constructor_output_gpr(

11806

                                                                    ctx, v234,

11807

);

11808

                                                                // Rule at src/isa/x64/lower.isle line 382.

11809

                                                                return Some(v235);

11810

11811

11812

11813

11814

11815

11816

11817

11818

11819

                            let v188 = C::use_bmi1(ctx);

11820

                            if v188 == true {

11821

                                let v171 = C::def_inst(ctx, v38.1);

11822

                                if let Some(v172) = v171 {

11823

                                    let v173 = &C::inst_data(ctx, v172);

11824

                                    if let &InstructionData::Unary {

11825

                                        opcode: ref v174,

11826

                                        arg: v175,

11827

                                    } = v173

11828

11829

                                        if let &Opcode::Ineg = v174 {

11830

                                            if v38.0 == v175 {

11831

                                                let v198 = &constructor_put_in_gpr_mem(ctx, v38.0);

11832

                                                let v209 = constructor_x64_blsi(ctx, v46, v198);

11833

                                                let v210 = constructor_output_gpr(ctx, v209);

11834

                                                // Rule at src/isa/x64/lower.isle line 369.

11835

                                                return Some(v210);

11836

11837

11838

11839

11840

                                let v180 = C::def_inst(ctx, v38.0);

11841

                                if let Some(v181) = v180 {

11842

                                    let v182 = &C::inst_data(ctx, v181);

11843

                                    if let &InstructionData::Unary {

11844

                                        opcode: ref v183,

11845

                                        arg: v184,

11846

                                    } = v182

11847

11848

                                        if let &Opcode::Ineg = v183 {

11849

                                            if v38.1 == v184 {

11850

                                                let v206 = &constructor_put_in_gpr_mem(ctx, v184);

11851

                                                let v207 = constructor_x64_blsi(ctx, v46, v206);

11852

                                                let v208 = constructor_output_gpr(ctx, v207);

11853

                                                // Rule at src/isa/x64/lower.isle line 366.

11854

                                                return Some(v208);

11855

11856

11857

11858

11859

                                let v201 = constructor_val_minus_one(ctx, v38.0);

11860

                                if let Some(v202) = v201 {

11861

                                    if v38.1 == v202 {

11862

                                        let v203 = &constructor_put_in_gpr_mem(ctx, v38.1);

11863

                                        let v204 = constructor_x64_blsr(ctx, v46, v203);

11864

                                        let v205 = constructor_output_gpr(ctx, v204);

11865

                                        // Rule at src/isa/x64/lower.isle line 359.

11866

                                        return Some(v205);

11867

11868

11869

                                if let Some(v197) = v196 {

11870

                                    if v38.0 == v197 {

11871

                                        let v198 = &constructor_put_in_gpr_mem(ctx, v38.0);

11872

                                        let v199 = constructor_x64_blsr(ctx, v46, v198);

11873

                                        let v200 = constructor_output_gpr(ctx, v199);

11874

                                        // Rule at src/isa/x64/lower.isle line 355.

11875

                                        return Some(v200);

11876

11877

11878

11879

11880

                        let v152 = C::ty_int_ref_scalar_64(ctx, v3);

11881

                        if let Some(v153) = v152 {

11882

                            let v188 = C::use_bmi1(ctx);

11883

                            if v188 == true {

11884

                                let v38 = C::unpack_value_array_2(ctx, v37);

11885

                                let v180 = C::def_inst(ctx, v38.0);

11886

                                if let Some(v181) = v180 {

11887

                                    let v182 = &C::inst_data(ctx, v181);

11888

                                    if let &InstructionData::Unary {

11889

                                        opcode: ref v183,

11890

                                        arg: v184,

11891

                                    } = v182

11892

11893

                                        if let &Opcode::Bnot = v183 {

11894

                                            let v193 = constructor_put_in_gpr(ctx, v184);

11895

                                            let v109 = &constructor_put_in_gpr_mem(ctx, v38.1);

11896

                                            let v194 = constructor_x64_andn(ctx, v3, v193, v109);

11897

                                            let v195 = constructor_output_gpr(ctx, v194);

11898

                                            // Rule at src/isa/x64/lower.isle line 343.

11899

                                            return Some(v195);

11900

11901

11902

11903

                                let v171 = C::def_inst(ctx, v38.1);

11904

                                if let Some(v172) = v171 {

11905

                                    let v173 = &C::inst_data(ctx, v172);

11906

                                    if let &InstructionData::Unary {

11907

                                        opcode: ref v174,

11908

                                        arg: v175,

11909

                                    } = v173

11910

11911

                                        if let &Opcode::Bnot = v174 {

11912

                                            let v189 = constructor_put_in_gpr(ctx, v175);

11913

                                            let v190 = &constructor_put_in_gpr_mem(ctx, v38.0);

11914

                                            let v191 = constructor_x64_andn(ctx, v3, v189, v190);

11915

                                            let v192 = constructor_output_gpr(ctx, v191);

11916

                                            // Rule at src/isa/x64/lower.isle line 338.

11917

                                            return Some(v192);

11918

11919

11920

11921

11922

11923

                        let v64 = C::multi_lane(ctx, v3);

11924

                        if let Some(v65) = v64 {

11925

                            let v38 = C::unpack_value_array_2(ctx, v37);

11926

                            let v180 = C::def_inst(ctx, v38.0);

11927

                            if let Some(v181) = v180 {

11928

                                let v182 = &C::inst_data(ctx, v181);

11929

                                if let &InstructionData::Unary {

11930

                                    opcode: ref v183,

11931

                                    arg: v184,

11932

                                } = v182

11933

11934

                                    if let &Opcode::Bnot = v183 {

11935

                                        let v185 = constructor_put_in_xmm(ctx, v184);

11936

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11937

                                        let v186 = constructor_sse_and_not(ctx, v3, v185, v69);

11938

                                        let v187 = constructor_output_xmm(ctx, v186);

11939

                                        // Rule at src/isa/x64/lower.isle line 335.

11940

                                        return Some(v187);

11941

11942

11943

11944

                            let v171 = C::def_inst(ctx, v38.1);

11945

                            if let Some(v172) = v171 {

11946

                                let v173 = &C::inst_data(ctx, v172);

11947

                                if let &InstructionData::Unary {

11948

                                    opcode: ref v174,

11949

                                    arg: v175,

11950

                                } = v173

11951

11952

                                    if let &Opcode::Bnot = v174 {

11953

                                        let v176 = constructor_put_in_xmm(ctx, v175);

11954

                                        let v177 = &C::put_in_xmm_mem(ctx, v38.0);

11955

                                        let v178 = constructor_sse_and_not(ctx, v3, v176, v177);

11956

                                        let v179 = constructor_output_xmm(ctx, v178);

11957

                                        // Rule at src/isa/x64/lower.isle line 333.

11958

                                        return Some(v179);

11959

11960

11961

11962

11963

                        if v3 == I128 {

11964

                            let v38 = C::unpack_value_array_2(ctx, v37);

11965

                            let v78 = C::put_in_regs(ctx, v38.0);

11966

                            let v168 = C::put_in_regs(ctx, v38.1);

11967

                            let v169 = constructor_and_i128(ctx, v78, v168);

11968

                            let v170 = C::output(ctx, v169);

11969

                            // Rule at src/isa/x64/lower.isle line 314.

11970

                            return Some(v170);

11971

11972

                        if let Some(v65) = v64 {

11973

                            let v38 = C::unpack_value_array_2(ctx, v37);

11974

                            let v68 = constructor_put_in_xmm(ctx, v38.0);

11975

                            let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11976

                            let v166 = constructor_sse_and(ctx, v3, v68, v69);

11977

                            let v167 = constructor_output_xmm(ctx, v166);

11978

                            // Rule at src/isa/x64/lower.isle line 297.

11979

                            return Some(v167);

11980

11981

                        let v162 = C::ty_scalar_float(ctx, v3);

11982

                        if let Some(v163) = v162 {

11983

                            let v38 = C::unpack_value_array_2(ctx, v37);

11984

                            let v68 = constructor_put_in_xmm(ctx, v38.0);

11985

                            let v69 = &C::put_in_xmm_mem(ctx, v38.1);

11986

                            let v164 = constructor_sse_and(ctx, v163, v68, v69);

11987

                            let v165 = constructor_output_xmm(ctx, v164);

11988

                            // Rule at src/isa/x64/lower.isle line 285.

11989

                            return Some(v165);

11990

11991

                        if let Some(v153) = v152 {

11992

                            let v38 = C::unpack_value_array_2(ctx, v37);

11993

                            let v158 = &C::simm32_from_value(ctx, v38.0);

11994

                            if let Some(v159) = v158 {

11995

                                let v60 = constructor_put_in_gpr(ctx, v38.1);

11996

                                let v160 = constructor_x64_and(ctx, v3, v60, v159);

11997

                                let v161 = constructor_output_gpr(ctx, v160);

11998

                                // Rule at src/isa/x64/lower.isle line 279.

11999

                                return Some(v161);

12000

12001

                            let v58 = &C::sinkable_load(ctx, v38.0);

12002

                            if let Some(v59) = v58 {

12003

                                let v60 = constructor_put_in_gpr(ctx, v38.1);

12004

                                let v61 = &constructor_sink_load_to_gpr_mem_imm(ctx, v59);

12005

                                let v156 = constructor_x64_and(ctx, v3, v60, v61);

12006

                                let v157 = constructor_output_gpr(ctx, v156);

12007

                                // Rule at src/isa/x64/lower.isle line 275.

12008

                                return Some(v157);

12009

12010

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

12011

                            let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);

12012

                            let v154 = constructor_x64_and(ctx, v3, v41, v42);

12013

                            let v155 = constructor_output_gpr(ctx, v154);

12014

                            // Rule at src/isa/x64/lower.isle line 268.

12015

                            return Some(v155);

12016

12017

12018

12019

                &Opcode::Bor => {

12020

                    let v1 = C::first_result(ctx, arg0);

12021

                    if let Some(v2) = v1 {

12022

                        let v3 = C::value_type(ctx, v2);

12023

                        if v3 == I128 {

12024

                            let v38 = C::unpack_value_array_2(ctx, v37);

12025

                            let v78 = C::put_in_regs(ctx, v38.0);

12026

                            let v168 = C::put_in_regs(ctx, v38.1);

12027

                            let v246 = constructor_or_i128(ctx, v78, v168);

12028

                            let v247 = C::output(ctx, v246);

12029

                            // Rule at src/isa/x64/lower.isle line 436.

12030

                            return Some(v247);

12031

12032

                        let v64 = C::multi_lane(ctx, v3);

12033

                        if let Some(v65) = v64 {

12034

                            let v38 = C::unpack_value_array_2(ctx, v37);

12035

                            let v68 = constructor_put_in_xmm(ctx, v38.0);

12036

                            let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12037

                            let v244 = constructor_sse_or(ctx, v3, v68, v69);

12038

                            let v245 = constructor_output_xmm(ctx, v244);

12039

                            // Rule at src/isa/x64/lower.isle line 421.

12040

                            return Some(v245);

12041

12042

                        let v162 = C::ty_scalar_float(ctx, v3);

12043

                        if let Some(v163) = v162 {

12044

                            let v38 = C::unpack_value_array_2(ctx, v37);

12045

                            let v68 = constructor_put_in_xmm(ctx, v38.0);

12046

                            let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12047

                            let v242 = constructor_sse_or(ctx, v163, v68, v69);

12048

                            let v243 = constructor_output_xmm(ctx, v242);

12049

                            // Rule at src/isa/x64/lower.isle line 409.

12050

                            return Some(v243);

12051

12052

                        let v152 = C::ty_int_ref_scalar_64(ctx, v3);

12053

                        if let Some(v153) = v152 {

12054

                            let v38 = C::unpack_value_array_2(ctx, v37);

12055

                            let v158 = &C::simm32_from_value(ctx, v38.0);

12056

                            if let Some(v159) = v158 {

12057

                                let v60 = constructor_put_in_gpr(ctx, v38.1);

12058

                                let v240 = constructor_x64_or(ctx, v3, v60, v159);

12059

                                let v241 = constructor_output_gpr(ctx, v240);

12060

                                // Rule at src/isa/x64/lower.isle line 403.

12061

                                return Some(v241);

12062

12063

                            let v58 = &C::sinkable_load(ctx, v38.0);

12064

                            if let Some(v59) = v58 {

12065

                                let v60 = constructor_put_in_gpr(ctx, v38.1);

12066

                                let v61 = &constructor_sink_load_to_gpr_mem_imm(ctx, v59);

12067

                                let v238 = constructor_x64_or(ctx, v3, v60, v61);

12068

                                let v239 = constructor_output_gpr(ctx, v238);

12069

                                // Rule at src/isa/x64/lower.isle line 399.

12070

                                return Some(v239);

12071

12072

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

12073

                            let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);

12074

                            let v236 = constructor_x64_or(ctx, v3, v41, v42);

12075

                            let v237 = constructor_output_gpr(ctx, v236);

12076

                            // Rule at src/isa/x64/lower.isle line 392.

12077

                            return Some(v237);

12078

12079

12080

12081

                &Opcode::Bxor => {

12082

                    let v1 = C::first_result(ctx, arg0);

12083

                    if let Some(v2) = v1 {

12084

                        let v3 = C::value_type(ctx, v2);

12085

                        let v45 = C::ty_32_or_64(ctx, v3);

12086

                        if let Some(v46) = v45 {

12087

                            let v188 = C::use_bmi1(ctx);

12088

                            if v188 == true {

12089

                                let v38 = C::unpack_value_array_2(ctx, v37);

12090

                                let v201 = constructor_val_minus_one(ctx, v38.0);

12091

                                if let Some(v202) = v201 {

12092

                                    if v38.1 == v202 {

12093

                                        let v203 = &constructor_put_in_gpr_mem(ctx, v38.1);

12094

                                        let v264 = constructor_x64_blsmsk(ctx, v46, v203);

12095

                                        let v265 = constructor_output_gpr(ctx, v264);

12096

                                        // Rule at src/isa/x64/lower.isle line 487.

12097

                                        return Some(v265);

12098

12099

12100

                                let v196 = constructor_val_minus_one(ctx, v38.1);

12101

                                if let Some(v197) = v196 {

12102

                                    if v38.0 == v197 {

12103

                                        let v198 = &constructor_put_in_gpr_mem(ctx, v38.0);

12104

                                        let v262 = constructor_x64_blsmsk(ctx, v46, v198);

12105

                                        let v263 = constructor_output_gpr(ctx, v262);

12106

                                        // Rule at src/isa/x64/lower.isle line 483.

12107

                                        return Some(v263);

12108

12109

12110

12111

12112

                        if v3 == I128 {

12113

                            let v38 = C::unpack_value_array_2(ctx, v37);

12114

                            let v78 = C::put_in_regs(ctx, v38.0);

12115

                            let v80 = constructor_value_regs_get_gpr(ctx, v78, 0x0);

12116

                            let v82 = constructor_value_regs_get_gpr(ctx, v78, 0x1);

12117

                            let v83 = C::put_in_regs(ctx, v38.1);

12118

                            let v84 = constructor_value_regs_get_gpr(ctx, v83, 0x0);

12119

                            let v85 = constructor_value_regs_get_gpr(ctx, v83, 0x1);

12120

                            let v86 = &C::gpr_to_gpr_mem_imm(ctx, v84);

12121

                            let v258 = constructor_x64_xor(ctx, I64, v80, v86);

12122

                            let v88 = &C::gpr_to_gpr_mem_imm(ctx, v85);

12123

                            let v259 = constructor_x64_xor(ctx, I64, v82, v88);

12124

                            let v260 = constructor_value_gprs(ctx, v258, v259);

12125

                            let v261 = C::output(ctx, v260);

12126

                            // Rule at src/isa/x64/lower.isle line 471.

12127

                            return Some(v261);

12128

12129

                        let v64 = C::multi_lane(ctx, v3);

12130

                        if let Some(v65) = v64 {

12131

                            let v38 = C::unpack_value_array_2(ctx, v37);

12132

                            let v68 = constructor_put_in_xmm(ctx, v38.0);

12133

                            let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12134

                            let v256 = constructor_x64_xor_vector(ctx, v3, v68, v69);

12135

                            let v257 = constructor_output_xmm(ctx, v256);

12136

                            // Rule at src/isa/x64/lower.isle line 466.

12137

                            return Some(v257);

12138

12139

                        let v162 = C::ty_scalar_float(ctx, v3);

12140

                        if let Some(v163) = v162 {

12141

                            let v38 = C::unpack_value_array_2(ctx, v37);

12142

                            let v68 = constructor_put_in_xmm(ctx, v38.0);

12143

                            let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12144

                            let v254 = constructor_x64_xor_vector(ctx, v163, v68, v69);

12145

                            let v255 = constructor_output_xmm(ctx, v254);

12146

                            // Rule at src/isa/x64/lower.isle line 461.

12147

                            return Some(v255);

12148

12149

                        let v152 = C::ty_int_ref_scalar_64(ctx, v3);

12150

                        if let Some(v153) = v152 {

12151

                            let v38 = C::unpack_value_array_2(ctx, v37);

12152

                            let v158 = &C::simm32_from_value(ctx, v38.0);

12153

                            if let Some(v159) = v158 {

12154

                                let v60 = constructor_put_in_gpr(ctx, v38.1);

12155

                                let v252 = constructor_x64_xor(ctx, v3, v60, v159);

12156

                                let v253 = constructor_output_gpr(ctx, v252);

12157

                                // Rule at src/isa/x64/lower.isle line 455.

12158

                                return Some(v253);

12159

12160

                            let v58 = &C::sinkable_load(ctx, v38.0);

12161

                            if let Some(v59) = v58 {

12162

                                let v60 = constructor_put_in_gpr(ctx, v38.1);

12163

                                let v61 = &constructor_sink_load_to_gpr_mem_imm(ctx, v59);

12164

                                let v250 = constructor_x64_xor(ctx, v3, v60, v61);

12165

                                let v251 = constructor_output_gpr(ctx, v250);

12166

                                // Rule at src/isa/x64/lower.isle line 451.

12167

                                return Some(v251);

12168

12169

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

12170

                            let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);

12171

                            let v248 = constructor_x64_xor(ctx, v3, v41, v42);

12172

                            let v249 = constructor_output_gpr(ctx, v248);

12173

                            // Rule at src/isa/x64/lower.isle line 444.

12174

                            return Some(v249);

12175

12176

12177

12178

                &Opcode::Rotl => {

12179

                    let v1 = C::first_result(ctx, arg0);

12180

                    if let Some(v2) = v1 {

12181

                        let v3 = C::value_type(ctx, v2);

12182

                        if v3 == I128 {

12183

                            let v38 = C::unpack_value_array_2(ctx, v37);

12184

                            let v78 = C::put_in_regs(ctx, v38.0);

12185

                            let v364 = constructor_lo_gpr(ctx, v38.1);

12186

                            let v365 = constructor_shl_i128(ctx, v78, v364);

12187

                            let v367 = constructor_imm(ctx, I64, 0x80);

12188

                            let v368 = C::gpr_new(ctx, v367);

12189

                            let v369 = &C::gpr_to_gpr_mem_imm(ctx, v364);

12190

                            let v370 = constructor_x64_sub(ctx, I64, v368, v369);

12191

                            let v371 = constructor_shr_i128(ctx, v78, v370);

12192

                            let v372 = constructor_or_i128(ctx, v365, v371);

12193

                            let v373 = C::output(ctx, v372);

12194

                            // Rule at src/isa/x64/lower.isle line 893.

12195

                            return Some(v373);

12196

12197

                        let v4 = C::fits_in_64(ctx, v3);

12198

                        if let Some(v5) = v4 {

12199

                            let v38 = C::unpack_value_array_2(ctx, v37);

12200

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

12201

                            let v266 = &constructor_put_masked_in_imm8_gpr(ctx, v38.1, v5);

12202

                            let v362 = constructor_x64_rotl(ctx, v5, v41, v266);

12203

                            let v363 = constructor_output_gpr(ctx, v362);

12204

                            // Rule at src/isa/x64/lower.isle line 887.

12205

                            return Some(v363);

12206

12207

12208

12209

                &Opcode::Rotr => {

12210

                    let v1 = C::first_result(ctx, arg0);

12211

                    if let Some(v2) = v1 {

12212

                        let v3 = C::value_type(ctx, v2);

12213

                        if v3 == I128 {

12214

                            let v38 = C::unpack_value_array_2(ctx, v37);

12215

                            let v78 = C::put_in_regs(ctx, v38.0);

12216

                            let v364 = constructor_lo_gpr(ctx, v38.1);

12217

                            let v376 = constructor_shr_i128(ctx, v78, v364);

12218

                            let v367 = constructor_imm(ctx, I64, 0x80);

12219

                            let v368 = C::gpr_new(ctx, v367);

12220

                            let v369 = &C::gpr_to_gpr_mem_imm(ctx, v364);

12221

                            let v370 = constructor_x64_sub(ctx, I64, v368, v369);

12222

                            let v377 = constructor_shl_i128(ctx, v78, v370);

12223

                            let v378 = constructor_or_i128(ctx, v376, v377);

12224

                            let v379 = C::output(ctx, v378);

12225

                            // Rule at src/isa/x64/lower.isle line 914.

12226

                            return Some(v379);

12227

12228

                        let v4 = C::fits_in_64(ctx, v3);

12229

                        if let Some(v5) = v4 {

12230

                            let v38 = C::unpack_value_array_2(ctx, v37);

12231

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

12232

                            let v266 = &constructor_put_masked_in_imm8_gpr(ctx, v38.1, v5);

12233

                            let v374 = constructor_x64_rotr(ctx, v5, v41, v266);

12234

                            let v375 = constructor_output_gpr(ctx, v374);

12235

                            // Rule at src/isa/x64/lower.isle line 908.

12236

                            return Some(v375);

12237

12238

12239

12240

                &Opcode::Ishl => {

12241

                    let v1 = C::first_result(ctx, arg0);

12242

                    if let Some(v2) = v1 {

12243

                        let v3 = C::value_type(ctx, v2);

12244

                        match v3 {

12245

                            I128 => {

12246

                                let v38 = C::unpack_value_array_2(ctx, v37);

12247

                                let v269 = constructor_lo_gpr(ctx, v38.1);

12248

                                let v270 = C::put_in_regs(ctx, v38.0);

12249

                                let v271 = constructor_shl_i128(ctx, v270, v269);

12250

                                let v272 = C::output(ctx, v271);

12251

                                // Rule at src/isa/x64/lower.isle line 535.

12252

                                return Some(v272);

12253

12254

                            I8X16 => {

12255

                                let v38 = C::unpack_value_array_2(ctx, v37);

12256

                                let v273 = &constructor_mask_xmm_shift(ctx, v3, v38.1);

12257

                                let v274 = constructor_put_in_xmm(ctx, v38.0);

12258

                                let v275 = &constructor_mov_rmi_to_xmm(ctx, v273);

12259

                                let v276 = constructor_x64_psllw(ctx, v274, v275);

12260

                                let v277 = &constructor_ishl_i8x16_mask(ctx, v273);

12261

                                let v280 = constructor_x64_load(ctx, I8X16, v277, &ExtKind::None);

12262

                                let v281 = RegMem::Reg { reg: v280 };

12263

                                let v282 = &C::reg_mem_to_xmm_mem(ctx, &v281);

12264

                                let v283 = constructor_sse_and(ctx, I8X16, v276, v282);

12265

                                let v284 = constructor_output_xmm(ctx, v283);

12266

                                // Rule at src/isa/x64/lower.isle line 547.

12267

                                return Some(v284);

12268

12269

                            I16X8 => {

12270

                                let v38 = C::unpack_value_array_2(ctx, v37);

12271

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12272

                                let v285 = &constructor_mask_xmm_shift(ctx, v3, v38.1);

12273

                                let v286 = &constructor_mov_rmi_to_xmm(ctx, v285);

12274

                                let v287 = constructor_x64_psllw(ctx, v68, v286);

12275

                                let v288 = constructor_output_xmm(ctx, v287);

12276

                                // Rule at src/isa/x64/lower.isle line 592.

12277

                                return Some(v288);

12278

12279

                            I32X4 => {

12280

                                let v38 = C::unpack_value_array_2(ctx, v37);

12281

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12282

                                let v285 = &constructor_mask_xmm_shift(ctx, v3, v38.1);

12283

                                let v286 = &constructor_mov_rmi_to_xmm(ctx, v285);

12284

                                let v289 = constructor_x64_pslld(ctx, v68, v286);

12285

                                let v290 = constructor_output_xmm(ctx, v289);

12286

                                // Rule at src/isa/x64/lower.isle line 595.

12287

                                return Some(v290);

12288

12289

                            I64X2 => {

12290

                                let v38 = C::unpack_value_array_2(ctx, v37);

12291

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12292

                                let v285 = &constructor_mask_xmm_shift(ctx, v3, v38.1);

12293

                                let v286 = &constructor_mov_rmi_to_xmm(ctx, v285);

12294

                                let v291 = constructor_x64_psllq(ctx, v68, v286);

12295

                                let v292 = constructor_output_xmm(ctx, v291);

12296

                                // Rule at src/isa/x64/lower.isle line 598.

12297

                                return Some(v292);

12298

12299

                            _ => {}

12300

12301

                        let v4 = C::fits_in_64(ctx, v3);

12302

                        if let Some(v5) = v4 {

12303

                            let v38 = C::unpack_value_array_2(ctx, v37);

12304

                            let v41 = constructor_put_in_gpr(ctx, v38.0);

12305

                            let v266 = &constructor_put_masked_in_imm8_gpr(ctx, v38.1, v5);

12306

                            let v267 = constructor_x64_shl(ctx, v5, v41, v266);

12307

                            let v268 = constructor_output_gpr(ctx, v267);

12308

                            // Rule at src/isa/x64/lower.isle line 496.

12309

                            return Some(v268);

12310

12311

12312

12313

                &Opcode::Ushr => {

12314

                    let v1 = C::first_result(ctx, arg0);

12315

                    if let Some(v2) = v1 {

12316

                        let v3 = C::value_type(ctx, v2);

12317

                        match v3 {

12318

                            I128 => {

12319

                                let v38 = C::unpack_value_array_2(ctx, v37);

12320

                                let v269 = constructor_lo_gpr(ctx, v38.1);

12321

                                let v270 = C::put_in_regs(ctx, v38.0);

12322

                                let v297 = constructor_shr_i128(ctx, v270, v269);

12323

                                let v298 = C::output(ctx, v297);

12324

                                // Rule at src/isa/x64/lower.isle line 642.

12325

                                return Some(v298);

12326

12327

                            I8X16 => {

12328

                                let v38 = C::unpack_value_array_2(ctx, v37);

12329

                                let v273 = &constructor_mask_xmm_shift(ctx, v3, v38.1);

12330

                                let v274 = constructor_put_in_xmm(ctx, v38.0);

12331

                                let v275 = &constructor_mov_rmi_to_xmm(ctx, v273);

12332

                                let v299 = constructor_x64_psrlw(ctx, v274, v275);

12333

                                let v300 = &constructor_ushr_i8x16_mask(ctx, v273);

12334

                                let v301 = &constructor_synthetic_amode_to_xmm_mem(ctx, v300);

12335

                                let v302 = constructor_sse_and(ctx, I8X16, v299, v301);

12336

                                let v303 = constructor_output_xmm(ctx, v302);

12337

                                // Rule at src/isa/x64/lower.isle line 652.

12338

                                return Some(v303);

12339

12340

                            I16X8 => {

12341

                                let v38 = C::unpack_value_array_2(ctx, v37);

12342

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12343

                                let v285 = &constructor_mask_xmm_shift(ctx, v3, v38.1);

12344

                                let v286 = &constructor_mov_rmi_to_xmm(ctx, v285);

12345

                                let v304 = constructor_x64_psrlw(ctx, v68, v286);

12346

                                let v305 = constructor_output_xmm(ctx, v304);

12347

                                // Rule at src/isa/x64/lower.isle line 698.

12348

                                return Some(v305);

12349

12350

                            I32X4 => {

12351

                                let v38 = C::unpack_value_array_2(ctx, v37);

12352

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12353

                                let v285 = &constructor_mask_xmm_shift(ctx, v3, v38.1);

12354

                                let v286 = &constructor_mov_rmi_to_xmm(ctx, v285);

12355

                                let v306 = constructor_x64_psrld(ctx, v68, v286);

12356

                                let v307 = constructor_output_xmm(ctx, v306);

12357

                                // Rule at src/isa/x64/lower.isle line 701.

12358

                                return Some(v307);

12359

12360

                            I64X2 => {

12361

                                let v38 = C::unpack_value_array_2(ctx, v37);

12362

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12363

                                let v285 = &constructor_mask_xmm_shift(ctx, v3, v38.1);

12364

                                let v286 = &constructor_mov_rmi_to_xmm(ctx, v285);

12365

                                let v308 = constructor_x64_psrlq(ctx, v68, v286);

12366

                                let v309 = constructor_output_xmm(ctx, v308);

12367

                                // Rule at src/isa/x64/lower.isle line 704.

12368

                                return Some(v309);

12369

12370

                            _ => {}

12371

12372

                        let v4 = C::fits_in_64(ctx, v3);

12373

                        if let Some(v5) = v4 {

12374

                            let v38 = C::unpack_value_array_2(ctx, v37);

12375

                            let v294 = constructor_extend_to_gpr(ctx, v38.0, v5, &ExtendKind::Zero);

12376

                            let v266 = &constructor_put_masked_in_imm8_gpr(ctx, v38.1, v5);

12377

                            let v295 = constructor_x64_shr(ctx, v5, v294, v266);

12378

                            let v296 = constructor_output_gpr(ctx, v295);

12379

                            // Rule at src/isa/x64/lower.isle line 605.

12380

                            return Some(v296);

12381

12382

12383

12384

                &Opcode::Sshr => {

12385

                    let v1 = C::first_result(ctx, arg0);

12386

                    if let Some(v2) = v1 {

12387

                        let v3 = C::value_type(ctx, v2);

12388

                        match v3 {

12389

                            I128 => {

12390

                                let v38 = C::unpack_value_array_2(ctx, v37);

12391

                                let v269 = constructor_lo_gpr(ctx, v38.1);

12392

                                let v270 = C::put_in_regs(ctx, v38.0);

12393

                                let v314 = constructor_sar_i128(ctx, v270, v269);

12394

                                let v315 = C::output(ctx, v314);

12395

                                // Rule at src/isa/x64/lower.isle line 754.

12396

                                return Some(v315);

12397

12398

                            I8X16 => {

12399

                                let v38 = C::unpack_value_array_2(ctx, v37);

12400

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12401

                                let v285 = &constructor_mask_xmm_shift(ctx, v3, v38.1);

12402

                                let v316 = &C::xmm_to_xmm_mem(ctx, v68);

12403

                                let v317 = constructor_x64_punpcklbw(ctx, v68, v316);

12404

                                let v318 = &C::xmm_to_xmm_mem(ctx, v68);

12405

                                let v319 = constructor_x64_punpckhbw(ctx, v68, v318);

12406

                                let v92 = C::value_type(ctx, v38.1);

12407

                                let v320 = &constructor_sshr_i8x16_bigger_shift(ctx, v92, v285);

12408

                                let v321 = constructor_x64_psraw(ctx, v317, v320);

12409

                                let v322 = constructor_x64_psraw(ctx, v319, v320);

12410

                                let v323 = &C::xmm_to_xmm_mem(ctx, v322);

12411

                                let v324 = constructor_x64_packsswb(ctx, v321, v323);

12412

                                let v325 = constructor_output_xmm(ctx, v324);

12413

                                // Rule at src/isa/x64/lower.isle line 775.

12414

                                return Some(v325);

12415

12416

                            I16X8 => {

12417

                                let v38 = C::unpack_value_array_2(ctx, v37);

12418

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12419

                                let v285 = &constructor_mask_xmm_shift(ctx, v3, v38.1);

12420

                                let v286 = &constructor_mov_rmi_to_xmm(ctx, v285);

12421

                                let v326 = constructor_x64_psraw(ctx, v68, v286);

12422

                                let v327 = constructor_output_xmm(ctx, v326);

12423

                                // Rule at src/isa/x64/lower.isle line 804.

12424

                                return Some(v327);

12425

12426

                            I32X4 => {

12427

                                let v38 = C::unpack_value_array_2(ctx, v37);

12428

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12429

                                let v285 = &constructor_mask_xmm_shift(ctx, v3, v38.1);

12430

                                let v286 = &constructor_mov_rmi_to_xmm(ctx, v285);

12431

                                let v328 = constructor_x64_psrad(ctx, v68, v286);

12432

                                let v329 = constructor_output_xmm(ctx, v328);

12433

                                // Rule at src/isa/x64/lower.isle line 807.

12434

                                return Some(v329);

12435

12436

                            I64X2 => {

12437

                                let v332 = C::use_avx512vl(ctx);

12438

                                if v332 == true {

12439

                                    let v333 = C::use_avx512f(ctx);

12440

                                    if v333 == true {

12441

                                        let v38 = C::unpack_value_array_2(ctx, v37);

12442

                                        let v171 = C::def_inst(ctx, v38.1);

12443

                                        if let Some(v172) = v171 {

12444

                                            let v173 = &C::inst_data(ctx, v172);

12445

                                            if let &InstructionData::UnaryImm {

12446

                                                opcode: ref v330,

12447

                                                imm: v331,

12448

                                            } = v173

12449

12450

                                                if let &Opcode::Iconst = v330 {

12451

                                                    let v334 = &C::put_in_xmm_mem(ctx, v38.0);

12452

                                                    let v335 =

12453

                                                        C::shift_amount_masked(ctx, v3, v331);

12454

                                                    let v336 =

12455

                                                        constructor_x64_vpsraq_imm(ctx, v334, v335);

12456

                                                    let v337 = constructor_output_xmm(ctx, v336);

12457

                                                    // Rule at src/isa/x64/lower.isle line 813.

12458

                                                    return Some(v337);

12459

12460

12461

12462

                                        let v60 = constructor_put_in_gpr(ctx, v38.1);

12463

                                        let v338 = C::shift_mask(ctx, v3);

12464

                                        let v339 = C::u8_as_u32(ctx, v338);

12465

                                        let v340 = RegMemImm::Imm { simm32: v339 };

12466

                                        let v341 = &C::gpr_mem_imm_new(ctx, &v340);

12467

                                        let v342 = constructor_x64_and(ctx, I64, v60, v341);

12468

                                        let v343 = constructor_put_in_xmm(ctx, v38.0);

12469

                                        let v344 = &C::gpr_to_gpr_mem(ctx, v342);

12470

                                        let v345 = constructor_x64_movd_to_xmm(ctx, v344);

12471

                                        let v346 = &C::xmm_to_xmm_mem(ctx, v345);

12472

                                        let v347 = constructor_x64_vpsraq(ctx, v343, v346);

12473

                                        let v348 = constructor_output_xmm(ctx, v347);

12474

                                        // Rule at src/isa/x64/lower.isle line 818.

12475

                                        return Some(v348);

12476

12477

12478

                                let v38 = C::unpack_value_array_2(ctx, v37);

12479

                                let v171 = C::def_inst(ctx, v38.1);

12480

                                if let Some(v172) = v171 {

12481

                                    let v173 = &C::inst_data(ctx, v172);

12482

                                    if let &InstructionData::UnaryImm {

12483

                                        opcode: ref v330,

12484

                                        imm: v331,

12485

                                    } = v173

12486

12487

                                        if let &Opcode::Iconst = v330 {

12488

                                            let v349 = C::u64_from_imm64(ctx, v331);

12489

                                            let v350 = C::u64_as_u32(ctx, v349);

12490

                                            if let Some(v351) = v350 {

12491

                                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12492

                                                let v353 = C::u32_and(ctx, v351, 0x3F);

12493

                                                let v354 = constructor_lower_i64x2_sshr_imm(

12494

                                                    ctx, v68, v353,

12495

);

12496

                                                let v355 = constructor_output_xmm(ctx, v354);

12497

                                                // Rule at src/isa/x64/lower.isle line 824.

12498

                                                return Some(v355);

12499

12500

12501

12502

12503

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12504

                                let v356 = constructor_put_in_gpr(ctx, v38.1);

12505

                                let v357 = RegMemImm::Imm { simm32: 0x3F };

12506

                                let v358 = &C::gpr_mem_imm_new(ctx, &v357);

12507

                                let v359 = constructor_x64_and(ctx, I64, v356, v358);

12508

                                let v360 = constructor_lower_i64x2_sshr_gpr(ctx, v68, v359);

12509

                                let v361 = constructor_output_xmm(ctx, v360);

12510

                                // Rule at src/isa/x64/lower.isle line 827.

12511

                                return Some(v361);

12512

12513

                            _ => {}

12514

12515

                        let v4 = C::fits_in_64(ctx, v3);

12516

                        if let Some(v5) = v4 {

12517

                            let v38 = C::unpack_value_array_2(ctx, v37);

12518

                            let v311 = constructor_extend_to_gpr(ctx, v38.0, v5, &ExtendKind::Sign);

12519

                            let v266 = &constructor_put_masked_in_imm8_gpr(ctx, v38.1, v5);

12520

                            let v312 = constructor_x64_sar(ctx, v5, v311, v266);

12521

                            let v313 = constructor_output_gpr(ctx, v312);

12522

                            // Rule at src/isa/x64/lower.isle line 717.

12523

                            return Some(v313);

12524

12525

12526

12527

                &Opcode::Fadd => {

12528

                    let v1 = C::first_result(ctx, arg0);

12529

                    if let Some(v2) = v1 {

12530

                        let v3 = C::value_type(ctx, v2);

12531

                        match v3 {

12532

                            F32 => {

12533

                                let v38 = C::unpack_value_array_2(ctx, v37);

12534

                                let v58 = &C::sinkable_load(ctx, v38.0);

12535

                                if let Some(v59) = v58 {

12536

                                    let v1249 = constructor_put_in_xmm(ctx, v38.1);

12537

                                    let v1260 = &constructor_sink_load_to_xmm_mem(ctx, v59);

12538

                                    let v1261 = constructor_x64_addss(ctx, v1249, v1260);

12539

                                    let v1262 = constructor_output_xmm(ctx, v1261);

12540

                                    // Rule at src/isa/x64/lower.isle line 2501.

12541

                                    return Some(v1262);

12542

12543

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12544

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12545

                                let v1252 = constructor_x64_addss(ctx, v68, v69);

12546

                                let v1253 = constructor_output_xmm(ctx, v1252);

12547

                                // Rule at src/isa/x64/lower.isle line 2490.

12548

                                return Some(v1253);

12549

12550

                            F64 => {

12551

                                let v38 = C::unpack_value_array_2(ctx, v37);

12552

                                let v58 = &C::sinkable_load(ctx, v38.0);

12553

                                if let Some(v59) = v58 {

12554

                                    let v1249 = constructor_put_in_xmm(ctx, v38.1);

12555

                                    let v1260 = &constructor_sink_load_to_xmm_mem(ctx, v59);

12556

                                    let v1263 = constructor_x64_addsd(ctx, v1249, v1260);

12557

                                    let v1264 = constructor_output_xmm(ctx, v1263);

12558

                                    // Rule at src/isa/x64/lower.isle line 2503.

12559

                                    return Some(v1264);

12560

12561

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12562

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12563

                                let v1254 = constructor_x64_addsd(ctx, v68, v69);

12564

                                let v1255 = constructor_output_xmm(ctx, v1254);

12565

                                // Rule at src/isa/x64/lower.isle line 2492.

12566

                                return Some(v1255);

12567

12568

                            F32X4 => {

12569

                                let v38 = C::unpack_value_array_2(ctx, v37);

12570

                                let v58 = &C::sinkable_load(ctx, v38.0);

12571

                                if let Some(v59) = v58 {

12572

                                    let v1249 = constructor_put_in_xmm(ctx, v38.1);

12573

                                    let v1260 = &constructor_sink_load_to_xmm_mem(ctx, v59);

12574

                                    let v1265 = constructor_x64_addps(ctx, v1249, v1260);

12575

                                    let v1266 = constructor_output_xmm(ctx, v1265);

12576

                                    // Rule at src/isa/x64/lower.isle line 2505.

12577

                                    return Some(v1266);

12578

12579

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12580

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12581

                                let v1256 = constructor_x64_addps(ctx, v68, v69);

12582

                                let v1257 = constructor_output_xmm(ctx, v1256);

12583

                                // Rule at src/isa/x64/lower.isle line 2494.

12584

                                return Some(v1257);

12585

12586

                            F64X2 => {

12587

                                let v38 = C::unpack_value_array_2(ctx, v37);

12588

                                let v58 = &C::sinkable_load(ctx, v38.0);

12589

                                if let Some(v59) = v58 {

12590

                                    let v1249 = constructor_put_in_xmm(ctx, v38.1);

12591

                                    let v1260 = &constructor_sink_load_to_xmm_mem(ctx, v59);

12592

                                    let v1267 = constructor_x64_addpd(ctx, v1249, v1260);

12593

                                    let v1268 = constructor_output_xmm(ctx, v1267);

12594

                                    // Rule at src/isa/x64/lower.isle line 2507.

12595

                                    return Some(v1268);

12596

12597

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12598

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12599

                                let v1258 = constructor_x64_addpd(ctx, v68, v69);

12600

                                let v1259 = constructor_output_xmm(ctx, v1258);

12601

                                // Rule at src/isa/x64/lower.isle line 2496.

12602

                                return Some(v1259);

12603

12604

                            _ => {}

12605

12606

12607

12608

                &Opcode::Fsub => {

12609

                    let v1 = C::first_result(ctx, arg0);

12610

                    if let Some(v2) = v1 {

12611

                        let v3 = C::value_type(ctx, v2);

12612

                        match v3 {

12613

                            F32 => {

12614

                                let v38 = C::unpack_value_array_2(ctx, v37);

12615

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12616

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12617

                                let v1269 = constructor_x64_subss(ctx, v68, v69);

12618

                                let v1270 = constructor_output_xmm(ctx, v1269);

12619

                                // Rule at src/isa/x64/lower.isle line 2512.

12620

                                return Some(v1270);

12621

12622

                            F64 => {

12623

                                let v38 = C::unpack_value_array_2(ctx, v37);

12624

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12625

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12626

                                let v1271 = constructor_x64_subsd(ctx, v68, v69);

12627

                                let v1272 = constructor_output_xmm(ctx, v1271);

12628

                                // Rule at src/isa/x64/lower.isle line 2514.

12629

                                return Some(v1272);

12630

12631

                            F32X4 => {

12632

                                let v38 = C::unpack_value_array_2(ctx, v37);

12633

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12634

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12635

                                let v1273 = constructor_x64_subps(ctx, v68, v69);

12636

                                let v1274 = constructor_output_xmm(ctx, v1273);

12637

                                // Rule at src/isa/x64/lower.isle line 2516.

12638

                                return Some(v1274);

12639

12640

                            F64X2 => {

12641

                                let v38 = C::unpack_value_array_2(ctx, v37);

12642

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12643

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12644

                                let v1275 = constructor_x64_subpd(ctx, v68, v69);

12645

                                let v1276 = constructor_output_xmm(ctx, v1275);

12646

                                // Rule at src/isa/x64/lower.isle line 2518.

12647

                                return Some(v1276);

12648

12649

                            _ => {}

12650

12651

12652

12653

                &Opcode::Fmul => {

12654

                    let v1 = C::first_result(ctx, arg0);

12655

                    if let Some(v2) = v1 {

12656

                        let v3 = C::value_type(ctx, v2);

12657

                        match v3 {

12658

                            F32 => {

12659

                                let v38 = C::unpack_value_array_2(ctx, v37);

12660

                                let v58 = &C::sinkable_load(ctx, v38.0);

12661

                                if let Some(v59) = v58 {

12662

                                    let v1249 = constructor_put_in_xmm(ctx, v38.1);

12663

                                    let v1260 = &constructor_sink_load_to_xmm_mem(ctx, v59);

12664

                                    let v1285 = constructor_x64_mulss(ctx, v1249, v1260);

12665

                                    let v1286 = constructor_output_xmm(ctx, v1285);

12666

                                    // Rule at src/isa/x64/lower.isle line 2534.

12667

                                    return Some(v1286);

12668

12669

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12670

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12671

                                let v1277 = constructor_x64_mulss(ctx, v68, v69);

12672

                                let v1278 = constructor_output_xmm(ctx, v1277);

12673

                                // Rule at src/isa/x64/lower.isle line 2523.

12674

                                return Some(v1278);

12675

12676

                            F64 => {

12677

                                let v38 = C::unpack_value_array_2(ctx, v37);

12678

                                let v58 = &C::sinkable_load(ctx, v38.0);

12679

                                if let Some(v59) = v58 {

12680

                                    let v1249 = constructor_put_in_xmm(ctx, v38.1);

12681

                                    let v1260 = &constructor_sink_load_to_xmm_mem(ctx, v59);

12682

                                    let v1287 = constructor_x64_mulsd(ctx, v1249, v1260);

12683

                                    let v1288 = constructor_output_xmm(ctx, v1287);

12684

                                    // Rule at src/isa/x64/lower.isle line 2536.

12685

                                    return Some(v1288);

12686

12687

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12688

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12689

                                let v1279 = constructor_x64_mulsd(ctx, v68, v69);

12690

                                let v1280 = constructor_output_xmm(ctx, v1279);

12691

                                // Rule at src/isa/x64/lower.isle line 2525.

12692

                                return Some(v1280);

12693

12694

                            F32X4 => {

12695

                                let v38 = C::unpack_value_array_2(ctx, v37);

12696

                                let v58 = &C::sinkable_load(ctx, v38.0);

12697

                                if let Some(v59) = v58 {

12698

                                    let v1249 = constructor_put_in_xmm(ctx, v38.1);

12699

                                    let v1260 = &constructor_sink_load_to_xmm_mem(ctx, v59);

12700

                                    let v1289 = constructor_x64_mulps(ctx, v1249, v1260);

12701

                                    let v1290 = constructor_output_xmm(ctx, v1289);

12702

                                    // Rule at src/isa/x64/lower.isle line 2538.

12703

                                    return Some(v1290);

12704

12705

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12706

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12707

                                let v1281 = constructor_x64_mulps(ctx, v68, v69);

12708

                                let v1282 = constructor_output_xmm(ctx, v1281);

12709

                                // Rule at src/isa/x64/lower.isle line 2527.

12710

                                return Some(v1282);

12711

12712

                            F64X2 => {

12713

                                let v38 = C::unpack_value_array_2(ctx, v37);

12714

                                let v58 = &C::sinkable_load(ctx, v38.0);

12715

                                if let Some(v59) = v58 {

12716

                                    let v1249 = constructor_put_in_xmm(ctx, v38.1);

12717

                                    let v1260 = &constructor_sink_load_to_xmm_mem(ctx, v59);

12718

                                    let v1291 = constructor_x64_mulpd(ctx, v1249, v1260);

12719

                                    let v1292 = constructor_output_xmm(ctx, v1291);

12720

                                    // Rule at src/isa/x64/lower.isle line 2540.

12721

                                    return Some(v1292);

12722

12723

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12724

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12725

                                let v1283 = constructor_x64_mulpd(ctx, v68, v69);

12726

                                let v1284 = constructor_output_xmm(ctx, v1283);

12727

                                // Rule at src/isa/x64/lower.isle line 2529.

12728

                                return Some(v1284);

12729

12730

                            _ => {}

12731

12732

12733

12734

                &Opcode::Fdiv => {

12735

                    let v1 = C::first_result(ctx, arg0);

12736

                    if let Some(v2) = v1 {

12737

                        let v3 = C::value_type(ctx, v2);

12738

                        match v3 {

12739

                            F32 => {

12740

                                let v38 = C::unpack_value_array_2(ctx, v37);

12741

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12742

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12743

                                let v1293 = constructor_x64_divss(ctx, v68, v69);

12744

                                let v1294 = constructor_output_xmm(ctx, v1293);

12745

                                // Rule at src/isa/x64/lower.isle line 2545.

12746

                                return Some(v1294);

12747

12748

                            F64 => {

12749

                                let v38 = C::unpack_value_array_2(ctx, v37);

12750

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12751

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12752

                                let v1295 = constructor_x64_divsd(ctx, v68, v69);

12753

                                let v1296 = constructor_output_xmm(ctx, v1295);

12754

                                // Rule at src/isa/x64/lower.isle line 2547.

12755

                                return Some(v1296);

12756

12757

                            F32X4 => {

12758

                                let v38 = C::unpack_value_array_2(ctx, v37);

12759

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12760

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12761

                                let v1297 = constructor_x64_divps(ctx, v68, v69);

12762

                                let v1298 = constructor_output_xmm(ctx, v1297);

12763

                                // Rule at src/isa/x64/lower.isle line 2549.

12764

                                return Some(v1298);

12765

12766

                            F64X2 => {

12767

                                let v38 = C::unpack_value_array_2(ctx, v37);

12768

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12769

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12770

                                let v1299 = constructor_x64_divpd(ctx, v68, v69);

12771

                                let v1300 = constructor_output_xmm(ctx, v1299);

12772

                                // Rule at src/isa/x64/lower.isle line 2551.

12773

                                return Some(v1300);

12774

12775

                            _ => {}

12776

12777

12778

12779

                &Opcode::Fcopysign => {

12780

                    let v1 = C::first_result(ctx, arg0);

12781

                    if let Some(v2) = v1 {

12782

                        let v3 = C::value_type(ctx, v2);

12783

                        match v3 {

12784

                            F32 => {

12785

                                let v38 = C::unpack_value_array_2(ctx, v37);

12786

                                let v2080 = C::value_type(ctx, v38.0);

12787

                                if v2080 == F32 {

12788

                                    let v2130 = constructor_imm(ctx, F32, 0x80000000);

12789

                                    let v2131 = C::xmm_new(ctx, v2130);

12790

                                    let v2132 = &C::put_in_xmm_mem(ctx, v38.0);

12791

                                    let v2133 = constructor_x64_andnps(ctx, v2131, v2132);

12792

                                    let v2134 = &C::put_in_xmm_mem(ctx, v38.1);

12793

                                    let v2135 = constructor_x64_andps(ctx, v2131, v2134);

12794

                                    let v2136 = &C::xmm_to_xmm_mem(ctx, v2135);

12795

                                    let v2137 = constructor_x64_orps(ctx, v2133, v2136);

12796

                                    let v2138 = constructor_output_xmm(ctx, v2137);

12797

                                    // Rule at src/isa/x64/lower.isle line 3916.

12798

                                    return Some(v2138);

12799

12800

12801

                            F64 => {

12802

                                let v38 = C::unpack_value_array_2(ctx, v37);

12803

                                let v2080 = C::value_type(ctx, v38.0);

12804

                                if v2080 == F64 {

12805

                                    let v2139 = constructor_imm(ctx, F64, 0x8000000000000000);

12806

                                    let v2140 = C::xmm_new(ctx, v2139);

12807

                                    let v2132 = &C::put_in_xmm_mem(ctx, v38.0);

12808

                                    let v2141 = constructor_x64_andnpd(ctx, v2140, v2132);

12809

                                    let v2134 = &C::put_in_xmm_mem(ctx, v38.1);

12810

                                    let v2142 = constructor_x64_andpd(ctx, v2140, v2134);

12811

                                    let v2143 = &C::xmm_to_xmm_mem(ctx, v2142);

12812

                                    let v2144 = constructor_x64_orpd(ctx, v2141, v2143);

12813

                                    let v2145 = constructor_output_xmm(ctx, v2144);

12814

                                    // Rule at src/isa/x64/lower.isle line 3922.

12815

                                    return Some(v2145);

12816

12817

12818

                            _ => {}

12819

12820

12821

12822

                &Opcode::Fmin => {

12823

                    let v1 = C::first_result(ctx, arg0);

12824

                    if let Some(v2) = v1 {

12825

                        let v3 = C::value_type(ctx, v2);

12826

                        match v3 {

12827

                            F32 => {

12828

                                let v38 = C::unpack_value_array_2(ctx, v37);

12829

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12830

                                let v444 = constructor_put_in_xmm(ctx, v38.1);

12831

                                let v1319 = constructor_xmm_min_max_seq(ctx, F32, true, v68, v444);

12832

                                let v1320 = constructor_output_xmm(ctx, v1319);

12833

                                // Rule at src/isa/x64/lower.isle line 2582.

12834

                                return Some(v1320);

12835

12836

                            F64 => {

12837

                                let v38 = C::unpack_value_array_2(ctx, v37);

12838

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12839

                                let v444 = constructor_put_in_xmm(ctx, v38.1);

12840

                                let v1321 = constructor_xmm_min_max_seq(ctx, F64, true, v68, v444);

12841

                                let v1322 = constructor_output_xmm(ctx, v1321);

12842

                                // Rule at src/isa/x64/lower.isle line 2584.

12843

                                return Some(v1322);

12844

12845

                            F32X4 => {

12846

                                let v38 = C::unpack_value_array_2(ctx, v37);

12847

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12848

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12849

                                let v1323 = constructor_x64_minps(ctx, v68, v69);

12850

                                let v1324 = constructor_put_in_xmm(ctx, v38.1);

12851

                                let v1325 = &C::put_in_xmm_mem(ctx, v38.0);

12852

                                let v1326 = constructor_x64_minps(ctx, v1324, v1325);

12853

                                let v1327 = &C::xmm_to_xmm_mem(ctx, v1326);

12854

                                let v1328 = constructor_x64_orps(ctx, v1323, v1327);

12855

                                let v1329 = &C::xmm_to_xmm_mem(ctx, v1326);

12856

                                let v1330 =

12857

                                    constructor_x64_cmpps(ctx, v1328, v1329, &FcmpImm::Unordered);

12858

                                let v1331 = &C::xmm_to_xmm_mem(ctx, v1330);

12859

                                let v1332 = constructor_x64_orps(ctx, v1328, v1331);

12860

                                let v1334 = &C::xmi_imm(ctx, 0xA);

12861

                                let v1335 = constructor_x64_psrld(ctx, v1330, v1334);

12862

                                let v1336 = &C::xmm_to_xmm_mem(ctx, v1332);

12863

                                let v1337 = constructor_x64_andnps(ctx, v1335, v1336);

12864

                                let v1338 = constructor_output_xmm(ctx, v1337);

12865

                                // Rule at src/isa/x64/lower.isle line 2599.

12866

                                return Some(v1338);

12867

12868

                            F64X2 => {

12869

                                let v38 = C::unpack_value_array_2(ctx, v37);

12870

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12871

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12872

                                let v1339 = constructor_x64_minpd(ctx, v68, v69);

12873

                                let v1324 = constructor_put_in_xmm(ctx, v38.1);

12874

                                let v1325 = &C::put_in_xmm_mem(ctx, v38.0);

12875

                                let v1340 = constructor_x64_minpd(ctx, v1324, v1325);

12876

                                let v1341 = &C::xmm_to_xmm_mem(ctx, v1340);

12877

                                let v1342 = constructor_x64_orpd(ctx, v1339, v1341);

12878

                                let v1343 = &C::xmm_to_xmm_mem(ctx, v1340);

12879

                                let v1344 =

12880

                                    constructor_x64_cmppd(ctx, v1339, v1343, &FcmpImm::Unordered);

12881

                                let v1345 = &C::xmm_to_xmm_mem(ctx, v1344);

12882

                                let v1346 = constructor_x64_orpd(ctx, v1342, v1345);

12883

                                let v1348 = &C::xmi_imm(ctx, 0xD);

12884

                                let v1349 = constructor_x64_psrlq(ctx, v1344, v1348);

12885

                                let v1350 = &C::xmm_to_xmm_mem(ctx, v1346);

12886

                                let v1351 = constructor_x64_andnpd(ctx, v1349, v1350);

12887

                                let v1352 = constructor_output_xmm(ctx, v1351);

12888

                                // Rule at src/isa/x64/lower.isle line 2642.

12889

                                return Some(v1352);

12890

12891

                            _ => {}

12892

12893

12894

12895

                &Opcode::Fmax => {

12896

                    let v1 = C::first_result(ctx, arg0);

12897

                    if let Some(v2) = v1 {

12898

                        let v3 = C::value_type(ctx, v2);

12899

                        match v3 {

12900

                            F32 => {

12901

                                let v38 = C::unpack_value_array_2(ctx, v37);

12902

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12903

                                let v444 = constructor_put_in_xmm(ctx, v38.1);

12904

                                let v1354 = constructor_xmm_min_max_seq(ctx, F32, false, v68, v444);

12905

                                let v1355 = constructor_output_xmm(ctx, v1354);

12906

                                // Rule at src/isa/x64/lower.isle line 2654.

12907

                                return Some(v1355);

12908

12909

                            F64 => {

12910

                                let v38 = C::unpack_value_array_2(ctx, v37);

12911

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12912

                                let v444 = constructor_put_in_xmm(ctx, v38.1);

12913

                                let v1356 = constructor_xmm_min_max_seq(ctx, F64, false, v68, v444);

12914

                                let v1357 = constructor_output_xmm(ctx, v1356);

12915

                                // Rule at src/isa/x64/lower.isle line 2656.

12916

                                return Some(v1357);

12917

12918

                            F32X4 => {

12919

                                let v38 = C::unpack_value_array_2(ctx, v37);

12920

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12921

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12922

                                let v1358 = constructor_x64_maxps(ctx, v68, v69);

12923

                                let v1324 = constructor_put_in_xmm(ctx, v38.1);

12924

                                let v1325 = &C::put_in_xmm_mem(ctx, v38.0);

12925

                                let v1359 = constructor_x64_maxps(ctx, v1324, v1325);

12926

                                let v1360 = &C::xmm_to_xmm_mem(ctx, v1359);

12927

                                let v1361 = constructor_x64_xorps(ctx, v1358, v1360);

12928

                                let v1362 = &C::xmm_to_xmm_mem(ctx, v1361);

12929

                                let v1363 = constructor_x64_orps(ctx, v1358, v1362);

12930

                                let v1364 = &C::xmm_to_xmm_mem(ctx, v1361);

12931

                                let v1365 = constructor_x64_subps(ctx, v1363, v1364);

12932

                                let v1366 = &C::xmm_to_xmm_mem(ctx, v1363);

12933

                                let v1367 =

12934

                                    constructor_x64_cmpps(ctx, v1363, v1366, &FcmpImm::Unordered);

12935

                                let v1368 = &C::xmi_imm(ctx, 0xA);

12936

                                let v1369 = constructor_x64_psrld(ctx, v1367, v1368);

12937

                                let v1370 = &C::xmm_to_xmm_mem(ctx, v1365);

12938

                                let v1371 = constructor_x64_andnps(ctx, v1369, v1370);

12939

                                let v1372 = constructor_output_xmm(ctx, v1371);

12940

                                // Rule at src/isa/x64/lower.isle line 2662.

12941

                                return Some(v1372);

12942

12943

                            F64X2 => {

12944

                                let v38 = C::unpack_value_array_2(ctx, v37);

12945

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

12946

                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12947

                                let v1373 = constructor_x64_maxpd(ctx, v68, v69);

12948

                                let v1324 = constructor_put_in_xmm(ctx, v38.1);

12949

                                let v1325 = &C::put_in_xmm_mem(ctx, v38.0);

12950

                                let v1374 = constructor_x64_maxpd(ctx, v1324, v1325);

12951

                                let v1375 = &C::xmm_to_xmm_mem(ctx, v1374);

12952

                                let v1376 = constructor_x64_xorpd(ctx, v1373, v1375);

12953

                                let v1377 = &C::xmm_to_xmm_mem(ctx, v1376);

12954

                                let v1378 = constructor_x64_orpd(ctx, v1373, v1377);

12955

                                let v1379 = &C::xmm_to_xmm_mem(ctx, v1376);

12956

                                let v1380 = constructor_x64_subpd(ctx, v1378, v1379);

12957

                                let v1381 = &C::xmm_to_xmm_mem(ctx, v1378);

12958

                                let v1382 =

12959

                                    constructor_x64_cmppd(ctx, v1378, v1381, &FcmpImm::Unordered);

12960

                                let v1383 = &C::xmi_imm(ctx, 0xD);

12961

                                let v1384 = constructor_x64_psrlq(ctx, v1382, v1383);

12962

                                let v1385 = &C::xmm_to_xmm_mem(ctx, v1380);

12963

                                let v1386 = constructor_x64_andnpd(ctx, v1384, v1385);

12964

                                let v1387 = constructor_output_xmm(ctx, v1386);

12965

                                // Rule at src/isa/x64/lower.isle line 2705.

12966

                                return Some(v1387);

12967

12968

                            _ => {}

12969

12970

12971

12972

                &Opcode::Snarrow => {

12973

                    let v1 = C::first_result(ctx, arg0);

12974

                    if let Some(v2) = v1 {

12975

                        let v3 = C::value_type(ctx, v2);

12976

                        match v3 {

12977

                            I8X16 => {

12978

                                let v38 = C::unpack_value_array_2(ctx, v37);

12979

                                let v2080 = C::value_type(ctx, v38.0);

12980

                                if v2080 == I16X8 {

12981

                                    let v68 = constructor_put_in_xmm(ctx, v38.0);

12982

                                    let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12983

                                    let v2081 = constructor_x64_packsswb(ctx, v68, v69);

12984

                                    let v2082 = constructor_output_xmm(ctx, v2081);

12985

                                    // Rule at src/isa/x64/lower.isle line 3802.

12986

                                    return Some(v2082);

12987

12988

12989

                            I16X8 => {

12990

                                let v38 = C::unpack_value_array_2(ctx, v37);

12991

                                let v2080 = C::value_type(ctx, v38.0);

12992

                                if v2080 == I32X4 {

12993

                                    let v68 = constructor_put_in_xmm(ctx, v38.0);

12994

                                    let v69 = &C::put_in_xmm_mem(ctx, v38.1);

12995

                                    let v2083 = constructor_x64_packssdw(ctx, v68, v69);

12996

                                    let v2084 = constructor_output_xmm(ctx, v2083);

12997

                                    // Rule at src/isa/x64/lower.isle line 3805.

12998

                                    return Some(v2084);

12999

13000

13001

                            I32X4 => {

13002

                                let v38 = C::unpack_value_array_2(ctx, v37);

13003

                                let v171 = C::def_inst(ctx, v38.1);

13004

                                if let Some(v172) = v171 {

13005

                                    let v173 = &C::inst_data(ctx, v172);

13006

                                    if let &InstructionData::UnaryConst {

13007

                                        opcode: ref v2088,

13008

                                        constant_handle: v2089,

13009

                                    } = v173

13010

13011

                                        if let &Opcode::Vconst = v2088 {

13012

                                            let v180 = C::def_inst(ctx, v38.0);

13013

                                            if let Some(v181) = v180 {

13014

                                                let v182 = &C::inst_data(ctx, v181);

13015

                                                if let &InstructionData::Unary {

13016

                                                    opcode: ref v183,

13017

                                                    arg: v184,

13018

                                                } = v182

13019

13020

                                                    match v183 {

13021

                                                        &Opcode::FcvtToSintSat => {

13022

                                                            let v2085 = C::first_result(ctx, v181);

13023

                                                            if let Some(v2086) = v2085 {

13024

                                                                let v2087 =

13025

                                                                    C::value_type(ctx, v2086);

13026

                                                                if v2087 == I64X2 {

13027

                                                                    let v2090 =

13028

                                                                        C::u128_from_constant(

13029

                                                                            ctx, v2089,

13030

);

13031

                                                                    if let Some(v2091) = v2090 {

13032

                                                                        if v2091 == 0x0 {

13033

                                                                            let v185 = constructor_put_in_xmm(ctx, v184);

13034

                                                                            let v2092 =

13035

                                                                                &C::xmm_to_xmm_mem(

13036

                                                                                    ctx, v185,

13037

);

13038

                                                                            let v2093 = constructor_x64_cmppd(ctx, v185, v2092, &FcmpImm::Equal);

13039

                                                                            let v2095 = C::emit_u128_le_const(ctx, 0x41DFFFFFFFC0000041DFFFFFFFC00000);

13040

                                                                            let v2096 = &constructor_const_to_xmm_mem(ctx, v2095);

13041

                                                                            let v2097 = constructor_x64_andps(ctx, v2093, v2096);

13042

                                                                            let v2098 =

13043

                                                                                &C::xmm_to_xmm_mem(

13044

                                                                                    ctx, v2097,

13045

);

13046

                                                                            let v2099 = constructor_x64_minpd(ctx, v185, v2098);

13047

                                                                            let v2100 =

13048

                                                                                &C::xmm_to_xmm_mem(

13049

                                                                                    ctx, v2099,

13050

);

13051

                                                                            let v2101 = constructor_x64_cvttpd2dq(ctx, v2100);

13052

                                                                            let v2102 = constructor_output_xmm(ctx, v2101);

13053

                                                                            // Rule at src/isa/x64/lower.isle line 3814.

13054

                                                                            return Some(v2102);

13055

13056

13057

13058

13059

13060

                                                        &Opcode::X86Cvtt2dq => {

13061

                                                            let v2085 = C::first_result(ctx, v181);

13062

                                                            if let Some(v2086) = v2085 {

13063

                                                                let v2087 =

13064

                                                                    C::value_type(ctx, v2086);

13065

                                                                if v2087 == I64X2 {

13066

                                                                    let v2090 =

13067

                                                                        C::u128_from_constant(

13068

                                                                            ctx, v2089,

13069

);

13070

                                                                    if let Some(v2091) = v2090 {

13071

                                                                        if v2091 == 0x0 {

13072

                                                                            let v499 =

13073

                                                                                &C::put_in_xmm_mem(

13074

                                                                                    ctx, v184,

13075

);

13076

                                                                            let v2103 = constructor_x64_cvttpd2dq(ctx, v499);

13077

                                                                            let v2104 = constructor_output_xmm(ctx, v2103);

13078

                                                                            // Rule at src/isa/x64/lower.isle line 3838.

13079

                                                                            return Some(v2104);

13080

13081

13082

13083

13084

13085

                                                        _ => {}

13086

13087

13088

13089

13090

13091

13092

13093

                            _ => {}

13094

13095

13096

13097

                &Opcode::Unarrow => {

13098

                    let v1 = C::first_result(ctx, arg0);

13099

                    if let Some(v2) = v1 {

13100

                        let v3 = C::value_type(ctx, v2);

13101

                        match v3 {

13102

                            I8X16 => {

13103

                                let v38 = C::unpack_value_array_2(ctx, v37);

13104

                                let v2080 = C::value_type(ctx, v38.0);

13105

                                if v2080 == I16X8 {

13106

                                    let v68 = constructor_put_in_xmm(ctx, v38.0);

13107

                                    let v69 = &C::put_in_xmm_mem(ctx, v38.1);

13108

                                    let v2105 = constructor_x64_packuswb(ctx, v68, v69);

13109

                                    let v2106 = constructor_output_xmm(ctx, v2105);

13110

                                    // Rule at src/isa/x64/lower.isle line 3844.

13111

                                    return Some(v2106);

13112

13113

13114

                            I16X8 => {

13115

                                let v38 = C::unpack_value_array_2(ctx, v37);

13116

                                let v2080 = C::value_type(ctx, v38.0);

13117

                                if v2080 == I32X4 {

13118

                                    let v441 = C::use_sse41(ctx);

13119

                                    if v441 == true {

13120

                                        let v68 = constructor_put_in_xmm(ctx, v38.0);

13121

                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);

13122

                                        let v2107 = constructor_x64_packusdw(ctx, v68, v69);

13123

                                        let v2108 = constructor_output_xmm(ctx, v2107);

13124

                                        // Rule at src/isa/x64/lower.isle line 3847.

13125

                                        return Some(v2108);

13126

13127

                                    let v68 = constructor_put_in_xmm(ctx, v38.0);

13128

                                    let v2109 =

13129

                                        constructor_unarrow_i32x4_lanes_to_low_u16_lanes(ctx, v68);

13130

                                    let v2110 = constructor_put_in_xmm(ctx, v38.1);

13131

                                    let v2111 = constructor_unarrow_i32x4_lanes_to_low_u16_lanes(

13132

                                        ctx, v2110,

13133

);

13134

                                    let v2112 = &C::xmm_to_xmm_mem(ctx, v2111);

13135

                                    let v2113 = constructor_x64_punpcklqdq(ctx, v2109, v2112);

13136

                                    let v2114 = constructor_output_xmm(ctx, v2113);

13137

                                    // Rule at src/isa/x64/lower.isle line 3857.

13138

                                    return Some(v2114);

13139

13140

13141

                            _ => {}

13142

13143

13144

13145

                &Opcode::Uunarrow => {

13146

                    let v38 = C::unpack_value_array_2(ctx, v37);

13147

                    let v171 = C::def_inst(ctx, v38.1);

13148

                    if let Some(v172) = v171 {

13149

                        let v173 = &C::inst_data(ctx, v172);

13150

                        if let &InstructionData::UnaryConst {

13151

                            opcode: ref v2088,

13152

                            constant_handle: v2089,

13153

                        } = v173

13154

13155

                            if let &Opcode::Vconst = v2088 {

13156

                                let v180 = C::def_inst(ctx, v38.0);

13157

                                if let Some(v181) = v180 {

13158

                                    let v182 = &C::inst_data(ctx, v181);

13159

                                    if let &InstructionData::Unary {

13160

                                        opcode: ref v183,

13161

                                        arg: v184,

13162

                                    } = v182

13163

13164

                                        if let &Opcode::FcvtToUintSat = v183 {

13165

                                            let v481 = C::value_type(ctx, v184);

13166

                                            if v481 == F64X2 {

13167

                                                let v2090 = C::u128_from_constant(ctx, v2089);

13168

                                                if let Some(v2091) = v2090 {

13169

                                                    if v2091 == 0x0 {

13170

                                                        let v185 =

13171

                                                            constructor_put_in_xmm(ctx, v184);

13172

                                                        let v2575 =

13173

                                                            constructor_xmm_zero(ctx, F64X2);

13174

                                                        let v2576 = &C::xmm_to_xmm_mem(ctx, v2575);

13175

                                                        let v2577 =

13176

                                                            constructor_x64_maxpd(ctx, v185, v2576);

13177

                                                        let v2579 = C::emit_u128_le_const(

13178

                                                            ctx,

13179

                                                            0x41EFFFFFFFE0000041EFFFFFFFE00000,

13180

);

13181

                                                        let v2580 = &constructor_const_to_xmm_mem(

13182

                                                            ctx, v2579,

13183

);

13184

                                                        let v2581 = constructor_x64_minpd(

13185

                                                            ctx, v2577, v2580,

13186

);

13187

                                                        let v2582 = C::xmm_to_reg(ctx, v2581);

13188

                                                        let v2583 =

13189

                                                            &constructor_xmm_to_reg_mem(ctx, v2582);

13190

                                                        let v2584 =

13191

                                                            &C::xmm_mem_to_reg_mem(ctx, v2583);

13192

                                                        let v2585 = constructor_x64_round(

13193

                                                            ctx,

13194

                                                            F64X2,

13195

                                                            v2584,

13196

                                                            &RoundImm::RoundZero,

13197

);

13198

                                                        let v2586 = C::emit_u128_le_const(

13199

                                                            ctx,

13200

                                                            0x43300000000000004330000000000000,

13201

);

13202

                                                        let v2587 = &constructor_const_to_xmm_mem(

13203

                                                            ctx, v2586,

13204

);

13205

                                                        let v2588 = constructor_x64_addpd(

13206

                                                            ctx, v2585, v2587,

13207

);

13208

                                                        let v2589 = &C::xmm_to_xmm_mem(ctx, v2575);

13209

                                                        let v2590 = constructor_x64_shufps(

13210

                                                            ctx, v2588, v2589, 0x88,

13211

);

13212

                                                        let v2591 =

13213

                                                            constructor_output_xmm(ctx, v2590);

13214

                                                        // Rule at src/isa/x64/lower.isle line 4691.

13215

                                                        return Some(v2591);

13216

13217

13218

13219

13220

13221

13222

13223

13224

13225

13226

                &Opcode::IaddPairwise => {

13227

                    let v1 = C::first_result(ctx, arg0);

13228

                    if let Some(v2) = v1 {

13229

                        let v3 = C::value_type(ctx, v2);

13230

                        match v3 {

13231

                            I8X16 => {

13232

                                let v1913 =

13233

                                    C::emit_u128_le_const(ctx, 0xFF00FF00FF00FF00FF00FF00FF00FF);

13234

                                let v1914 = &constructor_const_to_xmm_mem(ctx, v1913);

13235

                                let v1915 = constructor_x64_movdqu_load(ctx, v1914);

13236

                                let v38 = C::unpack_value_array_2(ctx, v37);

13237

                                let v1916 = constructor_put_in_xmm(ctx, v38.0);

13238

                                let v1917 = &C::xmm_to_xmm_mem(ctx, v1915);

13239

                                let v1918 = constructor_x64_pand(ctx, v1916, v1917);

13240

                                let v1919 = constructor_put_in_xmm(ctx, v38.1);

13241

                                let v1920 = &C::xmm_to_xmm_mem(ctx, v1915);

13242

                                let v1921 = constructor_x64_pand(ctx, v1919, v1920);

13243

                                let v1922 = &C::xmm_to_xmm_mem(ctx, v1921);

13244

                                let v1923 = constructor_x64_packuswb(ctx, v1918, v1922);

13245

                                let v1924 = constructor_put_in_xmm(ctx, v38.0);

13246

                                let v1926 = &C::xmi_imm(ctx, 0x8);

13247

                                let v1927 = constructor_x64_psrlw(ctx, v1924, v1926);

13248

                                let v1928 = constructor_put_in_xmm(ctx, v38.1);

13249

                                let v1929 = &C::xmi_imm(ctx, 0x8);

13250

                                let v1930 = constructor_x64_psrlw(ctx, v1928, v1929);

13251

                                let v1931 = &C::xmm_to_xmm_mem(ctx, v1930);

13252

                                let v1932 = constructor_x64_packuswb(ctx, v1927, v1931);

13253

                                let v1933 = &C::xmm_to_xmm_mem(ctx, v1932);

13254

                                let v1934 = constructor_x64_paddb(ctx, v1923, v1933);

13255

                                let v1935 = constructor_output_xmm(ctx, v1934);

13256

                                // Rule at src/isa/x64/lower.isle line 3591.

13257

                                return Some(v1935);

13258

13259

                            I16X8 => {

13260

                                let v525 = C::use_ssse3(ctx);

13261

                                if v525 == true {

13262

                                    let v38 = C::unpack_value_array_2(ctx, v37);

13263

                                    let v171 = C::def_inst(ctx, v38.1);

13264

                                    if let Some(v172) = v171 {

13265

                                        let v173 = &C::inst_data(ctx, v172);

13266

                                        if let &InstructionData::Unary {

13267

                                            opcode: ref v174,

13268

                                            arg: v175,

13269

                                        } = v173

13270

13271

                                            match v174 {

13272

                                                &Opcode::SwidenHigh => {

13273

                                                    let v180 = C::def_inst(ctx, v38.0);

13274

                                                    if let Some(v181) = v180 {

13275

                                                        let v182 = &C::inst_data(ctx, v181);

13276

                                                        if let &InstructionData::Unary {

13277

                                                            opcode: ref v183,

13278

                                                            arg: v184,

13279

                                                        } = v182

13280

13281

                                                            if let &Opcode::SwidenLow = v183 {

13282

                                                                if v175 == v184 {

13283

                                                                    let v481 =

13284

                                                                        C::value_type(ctx, v184);

13285

                                                                    if v481 == I8X16 {

13286

                                                                        let v1972 = C::emit_u128_le_const(ctx, 0x1010101010101010101010101010101);

13287

                                                                        let v1973 = constructor_x64_xmm_load_const(ctx, I8X16, v1972);

13288

                                                                        let v1974 =

13289

                                                                            &C::put_in_xmm_mem(

13290

                                                                                ctx, v184,

13291

);

13292

                                                                        let v1975 = constructor_x64_pmaddubsw(ctx, v1973, v1974);

13293

                                                                        let v1976 =

13294

                                                                            constructor_output_xmm(

13295

                                                                                ctx, v1975,

13296

);

13297

                                                                        // Rule at src/isa/x64/lower.isle line 3653.

13298

                                                                        return Some(v1976);

13299

13300

13301

13302

13303

13304

13305

                                                &Opcode::UwidenHigh => {

13306

                                                    let v180 = C::def_inst(ctx, v38.0);

13307

                                                    if let Some(v181) = v180 {

13308

                                                        let v182 = &C::inst_data(ctx, v181);

13309

                                                        if let &InstructionData::Unary {

13310

                                                            opcode: ref v183,

13311

                                                            arg: v184,

13312

                                                        } = v182

13313

13314

                                                            if let &Opcode::UwidenLow = v183 {

13315

                                                                if v175 == v184 {

13316

                                                                    let v481 =

13317

                                                                        C::value_type(ctx, v184);

13318

                                                                    if v481 == I8X16 {

13319

                                                                        let v1972 = C::emit_u128_le_const(ctx, 0x1010101010101010101010101010101);

13320

                                                                        let v1983 = &constructor_const_to_xmm_mem(ctx, v1972);

13321

                                                                        let v1980 =

13322

                                                                            constructor_put_in_xmm(

13323

                                                                                ctx, v184,

13324

);

13325

                                                                        let v1984 = constructor_x64_pmaddubsw(ctx, v1980, v1983);

13326

                                                                        let v1985 =

13327

                                                                            constructor_output_xmm(

13328

                                                                                ctx, v1984,

13329

);

13330

                                                                        // Rule at src/isa/x64/lower.isle line 3671.

13331

                                                                        return Some(v1985);

13332

13333

13334

13335

13336

13337

13338

                                                _ => {}

13339

13340

13341

13342

                                    let v68 = constructor_put_in_xmm(ctx, v38.0);

13343

                                    let v69 = &C::put_in_xmm_mem(ctx, v38.1);

13344

                                    let v1936 = constructor_x64_phaddw(ctx, v68, v69);

13345

                                    let v1937 = constructor_output_xmm(ctx, v1936);

13346

                                    // Rule at src/isa/x64/lower.isle line 3607.

13347

                                    return Some(v1937);

13348

13349

                                let v38 = C::unpack_value_array_2(ctx, v37);

13350

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

13351

                                let v444 = constructor_put_in_xmm(ctx, v38.1);

13352

                                let v316 = &C::xmm_to_xmm_mem(ctx, v68);

13353

                                let v1939 = constructor_x64_pshuflw(ctx, v316, 0xE8);

13354

                                let v1940 = &C::xmm_to_xmm_mem(ctx, v1939);

13355

                                let v1941 = constructor_x64_pshufhw(ctx, v1940, 0xE8);

13356

                                let v1942 = &C::xmm_to_xmm_mem(ctx, v1941);

13357

                                let v1943 = constructor_x64_pshufd(ctx, v1942, 0xE8);

13358

                                let v1944 = &C::xmm_to_xmm_mem(ctx, v444);

13359

                                let v1945 = constructor_x64_pshuflw(ctx, v1944, 0xE8);

13360

                                let v1946 = &C::xmm_to_xmm_mem(ctx, v1945);

13361

                                let v1947 = constructor_x64_pshufhw(ctx, v1946, 0xE8);

13362

                                let v1948 = &C::xmm_to_xmm_mem(ctx, v1947);

13363

                                let v1949 = constructor_x64_pshufd(ctx, v1948, 0xE8);

13364

                                let v1950 = &C::xmm_to_xmm_mem(ctx, v1949);

13365

                                let v1951 = constructor_x64_punpcklqdq(ctx, v1943, v1950);

13366

                                let v1952 = &C::xmi_imm(ctx, 0x10);

13367

                                let v1953 = constructor_x64_psrad(ctx, v68, v1952);

13368

                                let v1954 = &C::xmi_imm(ctx, 0x10);

13369

                                let v1955 = constructor_x64_psrad(ctx, v444, v1954);

13370

                                let v1956 = &C::xmm_to_xmm_mem(ctx, v1955);

13371

                                let v1957 = constructor_x64_packssdw(ctx, v1953, v1956);

13372

                                let v1958 = &C::xmm_to_xmm_mem(ctx, v1957);

13373

                                let v1959 = constructor_x64_paddw(ctx, v1951, v1958);

13374

                                let v1960 = constructor_output_xmm(ctx, v1959);

13375

                                // Rule at src/isa/x64/lower.isle line 3611.

13376

                                return Some(v1960);

13377

13378

                            I32X4 => {

13379

                                let v38 = C::unpack_value_array_2(ctx, v37);

13380

                                let v171 = C::def_inst(ctx, v38.1);

13381

                                if let Some(v172) = v171 {

13382

                                    let v173 = &C::inst_data(ctx, v172);

13383

                                    match v173 {

13384

                                        &InstructionData::Binary {

13385

                                            opcode: ref v2013,

13386

                                            args: ref v2014,

13387

                                        } => {

13388

                                            if let &Opcode::Imul = v2013 {

13389

                                                let v180 = C::def_inst(ctx, v38.0);

13390

                                                if let Some(v181) = v180 {

13391

                                                    let v182 = &C::inst_data(ctx, v181);

13392

                                                    if let &InstructionData::Binary {

13393

                                                        opcode: ref v1998,

13394

                                                        args: ref v1999,

13395

                                                    } = v182

13396

13397

                                                        if let &Opcode::Imul = v1998 {

13398

                                                            let v2000 =

13399

                                                                C::unpack_value_array_2(ctx, v1999);

13400

                                                            let v2003 = C::def_inst(ctx, v2000.0);

13401

                                                            if let Some(v2004) = v2003 {

13402

                                                                let v2005 =

13403

                                                                    &C::inst_data(ctx, v2004);

13404

                                                                if let &InstructionData::Unary {

13405

                                                                    opcode: ref v2006,

13406

                                                                    arg: v2007,

13407

                                                                } = v2005

13408

13409

                                                                    if let &Opcode::SwidenLow =

13410

                                                                        v2006

13411

13412

                                                                        let v2008 = C::def_inst(

13413

                                                                            ctx, v2000.1,

13414

);

13415

                                                                        if let Some(v2009) = v2008 {

13416

                                                                            let v2010 =

13417

                                                                                &C::inst_data(

13418

                                                                                    ctx, v2009,

13419

);

13420

                                                                            if let &InstructionData::Unary {

13421

                                                                                opcode: ref v2011,

13422

                                                                                arg: v2012,

13423

                                                                            } = v2010 {

13424

                                                                                if let &Opcode::SwidenLow = v2011 {

13425

                                                                                    let v2015 = C::unpack_value_array_2(ctx, v2014);

13426

                                                                                    let v2018 = C::def_inst(ctx, v2015.0);

13427

                                                                                    if let Some(v2019) = v2018 {

13428

                                                                                        let v2020 = &C::inst_data(ctx, v2019);

13429

                                                                                        if let &InstructionData::Unary {

13430

                                                                                            opcode: ref v2021,

13431

                                                                                            arg: v2022,

13432

                                                                                        } = v2020 {

13433

                                                                                            if let &Opcode::SwidenHigh = v2021 {

13434

                                                                                                if v2007 == v2022 {

13435

                                                                                                    let v2023 = C::def_inst(ctx, v2015.1);

13436

                                                                                                    if let Some(v2024) = v2023 {

13437

                                                                                                        let v2025 = &C::inst_data(ctx, v2024);

13438

                                                                                                        if let &InstructionData::Unary {

13439

                                                                                                            opcode: ref v2026,

13440

                                                                                                            arg: v2027,

13441

                                                                                                        } = v2025 {

13442

                                                                                                            if let &Opcode::SwidenHigh = v2026 {

13443

                                                                                                                if v2012 == v2027 {

13444

                                                                                                                    let v2028 = constructor_put_in_xmm(ctx, v2007);

13445

                                                                                                                    let v2029 = &C::put_in_xmm_mem(ctx, v2012);

13446

                                                                                                                    let v2030 = constructor_x64_pmaddwd(ctx, v2028, v2029);

13447

                                                                                                                    let v2031 = constructor_output_xmm(ctx, v2030);

13448

                                                                                                                    // Rule at src/isa/x64/lower.isle line 3694.

13449

                                                                                                                    return Some(v2031);

13450

13451

13452

13453

13454

13455

13456

13457

13458

13459

13460

13461

13462

13463

13464

13465

13466

13467

13468

13469

                                        &InstructionData::Unary {

13470

                                            opcode: ref v174,

13471

                                            arg: v175,

13472

                                        } => {

13473

                                            match v174 {

13474

                                                &Opcode::SwidenHigh => {

13475

                                                    let v180 = C::def_inst(ctx, v38.0);

13476

                                                    if let Some(v181) = v180 {

13477

                                                        let v182 = &C::inst_data(ctx, v181);

13478

                                                        if let &InstructionData::Unary {

13479

                                                            opcode: ref v183,

13480

                                                            arg: v184,

13481

                                                        } = v182

13482

13483

                                                            if let &Opcode::SwidenLow = v183 {

13484

                                                                if v175 == v184 {

13485

                                                                    let v481 =

13486

                                                                        C::value_type(ctx, v184);

13487

                                                                    if v481 == I16X8 {

13488

                                                                        let v1978 = C::emit_u128_le_const(ctx, 0x10001000100010001000100010001);

13489

                                                                        let v1979 = &constructor_const_to_xmm_mem(ctx, v1978);

13490

                                                                        let v1980 =

13491

                                                                            constructor_put_in_xmm(

13492

                                                                                ctx, v184,

13493

);

13494

                                                                        let v1981 =

13495

                                                                            constructor_x64_pmaddwd(

13496

                                                                                ctx, v1980, v1979,

13497

);

13498

                                                                        let v1982 =

13499

                                                                            constructor_output_xmm(

13500

                                                                                ctx, v1981,

13501

);

13502

                                                                        // Rule at src/isa/x64/lower.isle line 3663.

13503

                                                                        return Some(v1982);

13504

13505

13506

13507

13508

13509

13510

                                                &Opcode::UwidenHigh => {

13511

                                                    let v180 = C::def_inst(ctx, v38.0);

13512

                                                    if let Some(v181) = v180 {

13513

                                                        let v182 = &C::inst_data(ctx, v181);

13514

                                                        if let &InstructionData::Unary {

13515

                                                            opcode: ref v183,

13516

                                                            arg: v184,

13517

                                                        } = v182

13518

13519

                                                            if let &Opcode::UwidenLow = v183 {

13520

                                                                if v175 == v184 {

13521

                                                                    let v481 =

13522

                                                                        C::value_type(ctx, v184);

13523

                                                                    if v481 == I16X8 {

13524

                                                                        let v1987 = C::emit_u128_le_const(ctx, 0x80008000800080008000800080008000);

13525

                                                                        let v1988 = &constructor_const_to_xmm_mem(ctx, v1987);

13526

                                                                        let v1980 =

13527

                                                                            constructor_put_in_xmm(

13528

                                                                                ctx, v184,

13529

);

13530

                                                                        let v1989 =

13531

                                                                            constructor_x64_pxor(

13532

                                                                                ctx, v1980, v1988,

13533

);

13534

                                                                        let v1990 = C::emit_u128_le_const(ctx, 0x10001000100010001000100010001);

13535

                                                                        let v1991 = &constructor_const_to_xmm_mem(ctx, v1990);

13536

                                                                        let v1992 =

13537

                                                                            constructor_x64_pmaddwd(

13538

                                                                                ctx, v1989, v1991,

13539

);

13540

                                                                        let v1994 = C::emit_u128_le_const(ctx, 0x10000000100000001000000010000);

13541

                                                                        let v1995 = &constructor_const_to_xmm_mem(ctx, v1994);

13542

                                                                        let v1996 =

13543

                                                                            constructor_x64_paddd(

13544

                                                                                ctx, v1992, v1995,

13545

);

13546

                                                                        let v1997 =

13547

                                                                            constructor_output_xmm(

13548

                                                                                ctx, v1996,

13549

);

13550

                                                                        // Rule at src/isa/x64/lower.isle line 3680.

13551

                                                                        return Some(v1997);

13552

13553

13554

13555

13556

13557

13558

                                                _ => {}

13559

13560

13561

                                        _ => {}

13562

13563

13564

                                let v525 = C::use_ssse3(ctx);

13565

                                if v525 == true {

13566

                                    let v68 = constructor_put_in_xmm(ctx, v38.0);

13567

                                    let v69 = &C::put_in_xmm_mem(ctx, v38.1);

13568

                                    let v1961 = constructor_x64_phaddd(ctx, v68, v69);

13569

                                    let v1962 = constructor_output_xmm(ctx, v1961);

13570

                                    // Rule at src/isa/x64/lower.isle line 3637.

13571

                                    return Some(v1962);

13572

13573

                                let v68 = constructor_put_in_xmm(ctx, v38.0);

13574

                                let v444 = constructor_put_in_xmm(ctx, v38.1);

13575

                                let v1963 = &C::xmm_to_xmm_mem(ctx, v444);

13576

                                let v1965 = constructor_x64_shufps(ctx, v68, v1963, 0x88);

13577

                                let v447 = &C::xmm_to_xmm_mem(ctx, v444);

13578

                                let v1967 = constructor_x64_shufps(ctx, v68, v447, 0xDD);

13579

                                let v1968 = &C::xmm_to_xmm_mem(ctx, v1967);

13580

                                let v1969 = constructor_x64_paddd(ctx, v1965, v1968);

13581

                                let v1970 = constructor_output_xmm(ctx, v1969);

13582

                                // Rule at src/isa/x64/lower.isle line 3641.

13583

                                return Some(v1970);

13584

13585

                            _ => {}

13586

13587

13588

13589

                &Opcode::X86Pmaddubsw => {

13590

                    let v1 = C::first_result(ctx, arg0);

13591

                    if let Some(v2) = v1 {

13592

                        let v3 = C::value_type(ctx, v2);

13593

                        if v3 == I16X8 {

13594

                            let v525 = C::use_ssse3(ctx);

13595

                            if v525 == true {

13596

                                let v38 = C::unpack_value_array_2(ctx, v37);

13597

                                let v1249 = constructor_put_in_xmm(ctx, v38.1);

13598

                                let v177 = &C::put_in_xmm_mem(ctx, v38.0);

13599

                                let v1250 = constructor_x64_pmaddubsw(ctx, v1249, v177);

13600

                                let v1251 = constructor_output_xmm(ctx, v1250);

13601

                                // Rule at src/isa/x64/lower.isle line 2484.

13602

                                return Some(v1251);

13603

13604

13605

13606

13607

                &Opcode::Iconcat => {

13608

                    let v38 = C::unpack_value_array_2(ctx, v37);

13609

                    let v2080 = C::value_type(ctx, v38.0);

13610

                    if v2080 == I64 {

13611

                        let v2528 = C::put_in_reg(ctx, v38.0);

13612

                        let v2529 = C::put_in_reg(ctx, v38.1);

13613

                        let v2530 = C::value_regs(ctx, v2528, v2529);

13614

                        let v2531 = C::output(ctx, v2530);

13615

                        // Rule at src/isa/x64/lower.isle line 4607.

13616

                        return Some(v2531);

13617

13618

13619

                _ => {}

13620

13621

13622

        &InstructionData::BinaryImm8 {

13623

            opcode: ref v2364,

13624

            arg: v2365,

13625

            imm: v2366,

13626

        } => {

13627

            if let &Opcode::Extractlane = v2364 {

13628

                if v2366 == 0x0 {

13629

                    let v1 = C::first_result(ctx, arg0);

13630

                    if let Some(v2) = v1 {

13631

                        let v3 = C::value_type(ctx, v2);

13632

                        let v162 = C::ty_scalar_float(ctx, v3);

13633

                        if let Some(v163) = v162 {

13634

                            let v2367 = constructor_output_value(ctx, v2365);

13635

                            // Rule at src/isa/x64/lower.isle line 4370.

13636

                            return Some(v2367);

13637

13638

13639

13640

                let v2368 = C::value_type(ctx, v2365);

13641

                match v2368 {

13642

                    I8X16 => {

13643

                        let v441 = C::use_sse41(ctx);

13644

                        if v441 == true {

13645

                            let v2375 = constructor_put_in_xmm(ctx, v2365);

13646

                            let v2369 = C::u8_from_uimm8(ctx, v2366);

13647

                            let v2376 = constructor_x64_pextrb(ctx, v2375, v2369);

13648

                            let v2377 = constructor_output_gpr(ctx, v2376);

13649

                            // Rule at src/isa/x64/lower.isle line 4385.

13650

                            return Some(v2377);

13651

13652

                        let v2369 = C::u8_from_uimm8(ctx, v2366);

13653

                        let v2378 = C::u8_and(ctx, v2369, 0x1);

13654

                        match v2378 {

13655

                            0x0 => {

13656

                                let v2375 = constructor_put_in_xmm(ctx, v2365);

13657

                                let v2379 = C::u8_shr(ctx, v2369, 0x1);

13658

                                let v2380 = constructor_x64_pextrw(ctx, v2375, v2379);

13659

                                let v2384 = constructor_output_gpr(ctx, v2380);

13660

                                // Rule at src/isa/x64/lower.isle line 4396.

13661

                                return Some(v2384);

13662

13663

                            0x1 => {

13664

                                let v2375 = constructor_put_in_xmm(ctx, v2365);

13665

                                let v2379 = C::u8_shr(ctx, v2369, 0x1);

13666

                                let v2380 = constructor_x64_pextrw(ctx, v2375, v2379);

13667

                                let v1204 = Imm8Reg::Imm8 { imm: 0x8 };

13668

                                let v2381 = &C::imm8_reg_to_imm8_gpr(ctx, &v1204);

13669

                                let v2382 = constructor_x64_shr(ctx, I16, v2380, v2381);

13670

                                let v2383 = constructor_output_gpr(ctx, v2382);

13671

                                // Rule at src/isa/x64/lower.isle line 4389.

13672

                                return Some(v2383);

13673

13674

                            _ => {}

13675

13676

13677

                    I16X8 => {

13678

                        let v2375 = constructor_put_in_xmm(ctx, v2365);

13679

                        let v2369 = C::u8_from_uimm8(ctx, v2366);

13680

                        let v2385 = constructor_x64_pextrw(ctx, v2375, v2369);

13681

                        let v2386 = constructor_output_gpr(ctx, v2385);

13682

                        // Rule at src/isa/x64/lower.isle line 4401.

13683

                        return Some(v2386);

13684

13685

                    I32X4 => {

13686

                        let v441 = C::use_sse41(ctx);

13687

                        if v441 == true {

13688

                            let v2375 = constructor_put_in_xmm(ctx, v2365);

13689

                            let v2369 = C::u8_from_uimm8(ctx, v2366);

13690

                            let v2387 = constructor_x64_pextrd(ctx, v2375, v2369);

13691

                            let v2388 = constructor_output_gpr(ctx, v2387);

13692

                            // Rule at src/isa/x64/lower.isle line 4405.

13693

                            return Some(v2388);

13694

13695

                        if v2366 == 0x0 {

13696

                            let v2375 = constructor_put_in_xmm(ctx, v2365);

13697

                            let v2389 = constructor_x64_movd_to_gpr(ctx, v2375);

13698

                            let v2390 = constructor_output_gpr(ctx, v2389);

13699

                            // Rule at src/isa/x64/lower.isle line 4408.

13700

                            return Some(v2390);

13701

13702

                        let v2370 = &C::put_in_xmm_mem(ctx, v2365);

13703

                        let v2369 = C::u8_from_uimm8(ctx, v2366);

13704

                        let v2371 = constructor_x64_pshufd(ctx, v2370, v2369);

13705

                        let v2391 = constructor_x64_movd_to_gpr(ctx, v2371);

13706

                        let v2392 = constructor_output_gpr(ctx, v2391);

13707

                        // Rule at src/isa/x64/lower.isle line 4410.

13708

                        return Some(v2392);

13709

13710

                    I64X2 => {

13711

                        let v441 = C::use_sse41(ctx);

13712

                        if v441 == true {

13713

                            let v2375 = constructor_put_in_xmm(ctx, v2365);

13714

                            let v2369 = C::u8_from_uimm8(ctx, v2366);

13715

                            let v2393 = constructor_x64_pextrq(ctx, v2375, v2369);

13716

                            let v2394 = constructor_output_gpr(ctx, v2393);

13717

                            // Rule at src/isa/x64/lower.isle line 4414.

13718

                            return Some(v2394);

13719

13720

                        match v2366 {

13721

                            0x0 => {

13722

                                let v2375 = constructor_put_in_xmm(ctx, v2365);

13723

                                let v2395 = constructor_x64_movq_to_gpr(ctx, v2375);

13724

                                let v2396 = constructor_output_gpr(ctx, v2395);

13725

                                // Rule at src/isa/x64/lower.isle line 4417.

13726

                                return Some(v2396);

13727

13728

                            0x1 => {

13729

                                let v2370 = &C::put_in_xmm_mem(ctx, v2365);

13730

                                let v2397 = constructor_x64_pshufd(ctx, v2370, 0xE);

13731

                                let v2398 = constructor_x64_movq_to_gpr(ctx, v2397);

13732

                                let v2399 = constructor_output_gpr(ctx, v2398);

13733

                                // Rule at src/isa/x64/lower.isle line 4419.

13734

                                return Some(v2399);

13735

13736

                            _ => {}

13737

13738

13739

                    F32X4 => {

13740

                        let v2370 = &C::put_in_xmm_mem(ctx, v2365);

13741

                        let v2369 = C::u8_from_uimm8(ctx, v2366);

13742

                        let v2371 = constructor_x64_pshufd(ctx, v2370, v2369);

13743

                        let v2372 = constructor_output_xmm(ctx, v2371);

13744

                        // Rule at src/isa/x64/lower.isle line 4374.

13745

                        return Some(v2372);

13746

13747

                    F64X2 => {

13748

                        if v2366 == 0x1 {

13749

                            let v2370 = &C::put_in_xmm_mem(ctx, v2365);

13750

                            let v2373 = constructor_x64_pshufd(ctx, v2370, 0xEE);

13751

                            let v2374 = constructor_output_xmm(ctx, v2373);

13752

                            // Rule at src/isa/x64/lower.isle line 4378.

13753

                            return Some(v2374);

13754

13755

13756

                    _ => {}

13757

13758

13759

13760

        &InstructionData::Call {

13761

            opcode: ref v1755,

13762

            args: v1756,

13763

            func_ref: v1757,

13764

        } => {

13765

            match v1755 {

13766

                &Opcode::Call => {

13767

                    let v1759 = C::func_ref_data(ctx, v1757);

13768

                    let v1758 = C::value_list_slice(ctx, v1756);

13769

                    let v1763 = C::gen_call(ctx, v1759.0, v1759.1, v1759.2, v1758);

13770

                    // Rule at src/isa/x64/lower.isle line 3237.

13771

                    return Some(v1763);

13772

13773

                &Opcode::ReturnCall => {

13774

                    let v1759 = C::func_ref_data(ctx, v1757);

13775

                    let v1758 = C::value_list_slice(ctx, v1756);

13776

                    let v1773 = C::gen_return_call(ctx, v1759.0, v1759.1, v1759.2, v1758);

13777

                    // Rule at src/isa/x64/lower.isle line 3245.

13778

                    return Some(v1773);

13779

13780

                _ => {}

13781

13782

13783

        &InstructionData::CallIndirect {

13784

            opcode: ref v1764,

13785

            args: v1765,

13786

            sig_ref: v1766,

13787

        } => {

13788

            match v1764 {

13789

                &Opcode::CallIndirect => {

13790

                    let v1767 = C::value_list_slice(ctx, v1765);

13791

                    let v1768 = C::value_slice_unwrap(ctx, v1767);

13792

                    if let Some(v1769) = v1768 {

13793

                        let v1772 = C::gen_call_indirect(ctx, v1766, v1769.0, v1769.1);

13794

                        // Rule at src/isa/x64/lower.isle line 3240.

13795

                        return Some(v1772);

13796

13797

13798

                &Opcode::ReturnCallIndirect => {

13799

                    let v1767 = C::value_list_slice(ctx, v1765);

13800

                    let v1768 = C::value_slice_unwrap(ctx, v1767);

13801

                    if let Some(v1769) = v1768 {

13802

                        let v1774 = C::gen_return_call_indirect(ctx, v1766, v1769.0, v1769.1);

13803

                        // Rule at src/isa/x64/lower.isle line 3248.

13804

                        return Some(v1774);

13805

13806

13807

                _ => {}

13808

13809

13810

        &InstructionData::FloatCompare {

13811

            opcode: ref v957,

13812

            args: ref v958,

13813

            cond: ref v959,

13814

        } => {

13815

            if let &Opcode::Fcmp = v957 {

13816

                match v959 {

13817

                    &FloatCC::Equal => {

13818

                        let v960 = C::unpack_value_array_2(ctx, v958);

13819

                        let v963 = C::value_type(ctx, v960.0);

13820

                        let v969 = C::ty_vec128(ctx, v963);

13821

                        if let Some(v970) = v969 {

13822

                            let v971 = constructor_put_in_xmm(ctx, v960.0);

13823

                            let v972 = &C::put_in_xmm_mem(ctx, v960.1);

13824

                            let v974 = constructor_x64_cmpp(ctx, v970, v971, v972, &FcmpImm::Equal);

13825

                            let v975 = constructor_output_xmm(ctx, v974);

13826

                            // Rule at src/isa/x64/lower.isle line 2003.

13827

                            return Some(v975);

13828

13829

13830

                    &FloatCC::GreaterThan => {

13831

                        let v960 = C::unpack_value_array_2(ctx, v958);

13832

                        let v963 = C::value_type(ctx, v960.0);

13833

                        let v969 = C::ty_vec128(ctx, v963);

13834

                        if let Some(v970) = v969 {

13835

                            let v997 = constructor_put_in_xmm(ctx, v960.1);

13836

                            let v998 = &C::put_in_xmm_mem(ctx, v960.0);

13837

                            let v999 =

13838

                                constructor_x64_cmpp(ctx, v970, v997, v998, &FcmpImm::LessThan);

13839

                            let v1000 = constructor_output_xmm(ctx, v999);

13840

                            // Rule at src/isa/x64/lower.isle line 2023.

13841

                            return Some(v1000);

13842

13843

13844

                    &FloatCC::GreaterThanOrEqual => {

13845

                        let v960 = C::unpack_value_array_2(ctx, v958);

13846

                        let v963 = C::value_type(ctx, v960.0);

13847

                        let v969 = C::ty_vec128(ctx, v963);

13848

                        if let Some(v970) = v969 {

13849

                            let v997 = constructor_put_in_xmm(ctx, v960.1);

13850

                            let v998 = &C::put_in_xmm_mem(ctx, v960.0);

13851

                            let v1001 = constructor_x64_cmpp(

13852

                                ctx,

13853

                                v970,

13854

                                v997,

13855

                                v998,

13856

                                &FcmpImm::LessThanOrEqual,

13857

);

13858

                            let v1002 = constructor_output_xmm(ctx, v1001);

13859

                            // Rule at src/isa/x64/lower.isle line 2025.

13860

                            return Some(v1002);

13861

13862

13863

                    &FloatCC::LessThan => {

13864

                        let v960 = C::unpack_value_array_2(ctx, v958);

13865

                        let v963 = C::value_type(ctx, v960.0);

13866

                        let v969 = C::ty_vec128(ctx, v963);

13867

                        if let Some(v970) = v969 {

13868

                            let v971 = constructor_put_in_xmm(ctx, v960.0);

13869

                            let v972 = &C::put_in_xmm_mem(ctx, v960.1);

13870

                            let v980 =

13871

                                constructor_x64_cmpp(ctx, v970, v971, v972, &FcmpImm::LessThan);

13872

                            let v981 = constructor_output_xmm(ctx, v980);

13873

                            // Rule at src/isa/x64/lower.isle line 2007.

13874

                            return Some(v981);

13875

13876

13877

                    &FloatCC::LessThanOrEqual => {

13878

                        let v960 = C::unpack_value_array_2(ctx, v958);

13879

                        let v963 = C::value_type(ctx, v960.0);

13880

                        let v969 = C::ty_vec128(ctx, v963);

13881

                        if let Some(v970) = v969 {

13882

                            let v971 = constructor_put_in_xmm(ctx, v960.0);

13883

                            let v972 = &C::put_in_xmm_mem(ctx, v960.1);

13884

                            let v983 = constructor_x64_cmpp(

13885

                                ctx,

13886

                                v970,

13887

                                v971,

13888

                                v972,

13889

                                &FcmpImm::LessThanOrEqual,

13890

);

13891

                            let v984 = constructor_output_xmm(ctx, v983);

13892

                            // Rule at src/isa/x64/lower.isle line 2009.

13893

                            return Some(v984);

13894

13895

13896

                    &FloatCC::NotEqual => {

13897

                        let v960 = C::unpack_value_array_2(ctx, v958);

13898

                        let v963 = C::value_type(ctx, v960.0);

13899

                        let v969 = C::ty_vec128(ctx, v963);

13900

                        if let Some(v970) = v969 {

13901

                            let v971 = constructor_put_in_xmm(ctx, v960.0);

13902

                            let v972 = &C::put_in_xmm_mem(ctx, v960.1);

13903

                            let v977 =

13904

                                constructor_x64_cmpp(ctx, v970, v971, v972, &FcmpImm::NotEqual);

13905

                            let v978 = constructor_output_xmm(ctx, v977);

13906

                            // Rule at src/isa/x64/lower.isle line 2005.

13907

                            return Some(v978);

13908

13909

13910

                    &FloatCC::Ordered => {

13911

                        let v960 = C::unpack_value_array_2(ctx, v958);

13912

                        let v963 = C::value_type(ctx, v960.0);

13913

                        let v969 = C::ty_vec128(ctx, v963);

13914

                        if let Some(v970) = v969 {

13915

                            let v971 = constructor_put_in_xmm(ctx, v960.0);

13916

                            let v972 = &C::put_in_xmm_mem(ctx, v960.1);

13917

                            let v986 =

13918

                                constructor_x64_cmpp(ctx, v970, v971, v972, &FcmpImm::Ordered);

13919

                            let v987 = constructor_output_xmm(ctx, v986);

13920

                            // Rule at src/isa/x64/lower.isle line 2011.

13921

                            return Some(v987);

13922

13923

13924

                    &FloatCC::Unordered => {

13925

                        let v960 = C::unpack_value_array_2(ctx, v958);

13926

                        let v963 = C::value_type(ctx, v960.0);

13927

                        let v969 = C::ty_vec128(ctx, v963);

13928

                        if let Some(v970) = v969 {

13929

                            let v971 = constructor_put_in_xmm(ctx, v960.0);

13930

                            let v972 = &C::put_in_xmm_mem(ctx, v960.1);

13931

                            let v989 =

13932

                                constructor_x64_cmpp(ctx, v970, v971, v972, &FcmpImm::Unordered);

13933

                            let v990 = constructor_output_xmm(ctx, v989);

13934

                            // Rule at src/isa/x64/lower.isle line 2013.

13935

                            return Some(v990);

13936

13937

13938

                    &FloatCC::UnorderedOrGreaterThan => {

13939

                        let v960 = C::unpack_value_array_2(ctx, v958);

13940

                        let v963 = C::value_type(ctx, v960.0);

13941

                        let v969 = C::ty_vec128(ctx, v963);

13942

                        if let Some(v970) = v969 {

13943

                            let v971 = constructor_put_in_xmm(ctx, v960.0);

13944

                            let v972 = &C::put_in_xmm_mem(ctx, v960.1);

13945

                            let v992 = constructor_x64_cmpp(

13946

                                ctx,

13947

                                v970,

13948

                                v971,

13949

                                v972,

13950

                                &FcmpImm::UnorderedOrGreaterThan,

13951

);

13952

                            let v993 = constructor_output_xmm(ctx, v992);

13953

                            // Rule at src/isa/x64/lower.isle line 2015.

13954

                            return Some(v993);

13955

13956

13957

                    &FloatCC::UnorderedOrGreaterThanOrEqual => {

13958

                        let v960 = C::unpack_value_array_2(ctx, v958);

13959

                        let v963 = C::value_type(ctx, v960.0);

13960

                        let v969 = C::ty_vec128(ctx, v963);

13961

                        if let Some(v970) = v969 {

13962

                            let v971 = constructor_put_in_xmm(ctx, v960.0);

13963

                            let v972 = &C::put_in_xmm_mem(ctx, v960.1);

13964

                            let v995 = constructor_x64_cmpp(

13965

                                ctx,

13966

                                v970,

13967

                                v971,

13968

                                v972,

13969

                                &FcmpImm::UnorderedOrGreaterThanOrEqual,

13970

);

13971

                            let v996 = constructor_output_xmm(ctx, v995);

13972

                            // Rule at src/isa/x64/lower.isle line 2017.

13973

                            return Some(v996);

13974

13975

13976

                    &FloatCC::UnorderedOrLessThan => {

13977

                        let v960 = C::unpack_value_array_2(ctx, v958);

13978

                        let v963 = C::value_type(ctx, v960.0);

13979

                        let v969 = C::ty_vec128(ctx, v963);

13980

                        if let Some(v970) = v969 {

13981

                            let v997 = constructor_put_in_xmm(ctx, v960.1);

13982

                            let v998 = &C::put_in_xmm_mem(ctx, v960.0);

13983

                            let v1003 = constructor_x64_cmpp(

13984

                                ctx,

13985

                                v970,

13986

                                v997,

13987

                                v998,

13988

                                &FcmpImm::UnorderedOrGreaterThan,

13989

);

13990

                            let v1004 = constructor_output_xmm(ctx, v1003);

13991

                            // Rule at src/isa/x64/lower.isle line 2027.

13992

                            return Some(v1004);

13993

13994

13995

                    &FloatCC::UnorderedOrLessThanOrEqual => {

13996

                        let v960 = C::unpack_value_array_2(ctx, v958);

13997

                        let v963 = C::value_type(ctx, v960.0);

13998

                        let v969 = C::ty_vec128(ctx, v963);

13999

                        if let Some(v970) = v969 {

14000

                            let v997 = constructor_put_in_xmm(ctx, v960.1);

14001

                            let v998 = &C::put_in_xmm_mem(ctx, v960.0);

14002

                            let v1005 = constructor_x64_cmpp(

14003

                                ctx,

14004

                                v970,

14005

                                v997,

14006

                                v998,

14007

                                &FcmpImm::UnorderedOrGreaterThanOrEqual,

14008

);

14009

                            let v1006 = constructor_output_xmm(ctx, v1005);

14010

                            // Rule at src/isa/x64/lower.isle line 2029.

14011

                            return Some(v1006);

14012

14013

14014

                    _ => {}

14015

14016

                let v960 = C::unpack_value_array_2(ctx, v958);

14017

                let v963 = C::value_type(ctx, v960.0);

14018

                let v964 = C::ty_scalar_float(ctx, v963);

14019

                if let Some(v965) = v964 {

14020

                    let v966 = &constructor_emit_fcmp(ctx, v959, v960.0, v960.1);

14021

                    let v967 = constructor_lower_fcmp_bool(ctx, v966);

14022

                    let v968 = C::output(ctx, v967);

14023

                    // Rule at src/isa/x64/lower.isle line 1996.

14024

                    return Some(v968);

14025

14026

14027

14028

        &InstructionData::FuncAddr {

14029

            opcode: ref v1679,

14030

            func_ref: v1680,

14031

        } => {

14032

            if let &Opcode::FuncAddr = v1679 {

14033

                let v1681 = C::func_ref_data(ctx, v1680);

14034

                let v1686 = constructor_load_ext_name(ctx, v1681.1, 0x0, v1681.2);

14035

                let v1687 = constructor_output_reg(ctx, v1686);

14036

                // Rule at src/isa/x64/lower.isle line 3179.

14037

                return Some(v1687);

14038

14039

14040

        &InstructionData::IntAddTrap {

14041

            opcode: ref v791,

14042

            args: ref v792,

14043

            code: ref v793,

14044

        } => {

14045

            if let &Opcode::UaddOverflowTrap = v791 {

14046

                let v1 = C::first_result(ctx, arg0);

14047

                if let Some(v2) = v1 {

14048

                    let v3 = C::value_type(ctx, v2);

14049

                    let v4 = C::fits_in_64(ctx, v3);

14050

                    if let Some(v5) = v4 {

14051

                        let v794 = C::unpack_value_array_2(ctx, v792);

14052

                        let v810 = &C::sinkable_load(ctx, v794.0);

14053

                        if let Some(v811) = v810 {

14054

                            let v805 = constructor_put_in_gpr(ctx, v794.1);

14055

                            let v812 = &constructor_sink_load_to_gpr_mem_imm(ctx, v811);

14056

                            let v813 = &constructor_x64_add_with_flags_paired(ctx, v5, v805, v812);

14057

                            let v800 = &constructor_trap_if(ctx, &CC::B, v793);

14058

                            let v814 = constructor_with_flags(ctx, v813, v800);

14059

                            let v815 = C::output(ctx, v814);

14060

                            // Rule at src/isa/x64/lower.isle line 1784.

14061

                            return Some(v815);

14062

14063

                        let v803 = &C::simm32_from_value(ctx, v794.0);

14064

                        if let Some(v804) = v803 {

14065

                            let v805 = constructor_put_in_gpr(ctx, v794.1);

14066

                            let v806 = &constructor_x64_add_with_flags_paired(ctx, v5, v805, v804);

14067

                            let v807 = &constructor_trap_if(ctx, &CC::B, v793);

14068

                            let v808 = constructor_with_flags(ctx, v806, v807);

14069

                            let v809 = C::output(ctx, v808);

14070

                            // Rule at src/isa/x64/lower.isle line 1778.

14071

                            return Some(v809);

14072

14073

                        let v797 = constructor_put_in_gpr(ctx, v794.0);

14074

                        let v798 = &constructor_put_in_gpr_mem_imm(ctx, v794.1);

14075

                        let v799 = &constructor_x64_add_with_flags_paired(ctx, v5, v797, v798);

14076

                        let v800 = &constructor_trap_if(ctx, &CC::B, v793);

14077

                        let v801 = constructor_with_flags(ctx, v799, v800);

14078

                        let v802 = C::output(ctx, v801);

14079

                        // Rule at src/isa/x64/lower.isle line 1770.

14080

                        return Some(v802);

14081

14082

14083

14084

14085

        &InstructionData::IntCompare {

14086

            opcode: ref v820,

14087

            args: ref v821,

14088

            cond: ref v822,

14089

        } => {

14090

            if let &Opcode::Icmp = v820 {

14091

                match v822 {

14092

                    &IntCC::Equal => {

14093

                        let v823 = C::unpack_value_array_2(ctx, v821);

14094

                        let v826 = C::value_type(ctx, v823.0);

14095

                        let v874 = C::ty_vec128(ctx, v826);

14096

                        if let Some(v875) = v874 {

14097

                            let v876 = constructor_put_in_xmm(ctx, v823.0);

14098

                            let v877 = &C::put_in_xmm_mem(ctx, v823.1);

14099

                            let v878 = constructor_x64_pcmpeq(ctx, v875, v876, v877);

14100

                            let v879 = constructor_output_xmm(ctx, v878);

14101

                            // Rule at src/isa/x64/lower.isle line 1846.

14102

                            return Some(v879);

14103

14104

14105

                    &IntCC::NotEqual => {

14106

                        let v823 = C::unpack_value_array_2(ctx, v821);

14107

                        let v826 = C::value_type(ctx, v823.0);

14108

                        let v874 = C::ty_vec128(ctx, v826);

14109

                        if let Some(v875) = v874 {

14110

                            let v876 = constructor_put_in_xmm(ctx, v823.0);

14111

                            let v877 = &C::put_in_xmm_mem(ctx, v823.1);

14112

                            let v878 = constructor_x64_pcmpeq(ctx, v875, v876, v877);

14113

                            let v880 = constructor_vector_all_ones(ctx);

14114

                            let v881 = &C::xmm_to_xmm_mem(ctx, v880);

14115

                            let v882 = constructor_x64_pxor(ctx, v878, v881);

14116

                            let v883 = constructor_output_xmm(ctx, v882);

14117

                            // Rule at src/isa/x64/lower.isle line 1851.

14118

                            return Some(v883);

14119

14120

14121

                    &IntCC::SignedGreaterThan => {

14122

                        let v1 = C::first_result(ctx, arg0);

14123

                        if let Some(v2) = v1 {

14124

                            let v3 = C::value_type(ctx, v2);

14125

                            if v3 == I8 {

14126

                                let v823 = C::unpack_value_array_2(ctx, v821);

14127

                                let v844 = C::def_inst(ctx, v823.0);

14128

                                if let Some(v845) = v844 {

14129

                                    let v846 = &C::inst_data(ctx, v845);

14130

                                    if let &InstructionData::UnaryImm {

14131

                                        opcode: ref v847,

14132

                                        imm: v848,

14133

                                    } = v846

14134

14135

                                        if let &Opcode::Iconst = v847 {

14136

                                            let v849 = C::u64_from_imm64(ctx, v848);

14137

                                            if v849 == 0x0 {

14138

                                                let v850 = C::value_type(ctx, v823.1);

14139

                                                match v850 {

14140

                                                    I32 => {

14141

                                                        let v851 =

14142

                                                            constructor_put_in_gpr(ctx, v823.1);

14143

                                                        let v863 = Imm8Reg::Imm8 { imm: 0x1F };

14144

                                                        let v864 =

14145

                                                            &C::imm8_reg_to_imm8_gpr(ctx, &v863);

14146

                                                        let v867 = constructor_x64_shr(

14147

                                                            ctx, I32, v851, v864,

14148

);

14149

                                                        let v868 =

14150

                                                            constructor_output_gpr(ctx, v867);

14151

                                                        // Rule at src/isa/x64/lower.isle line 1830.

14152

                                                        return Some(v868);

14153

14154

                                                    I64 => {

14155

                                                        let v851 =

14156

                                                            constructor_put_in_gpr(ctx, v823.1);

14157

                                                        let v840 = Imm8Reg::Imm8 { imm: 0x3F };

14158

                                                        let v841 =

14159

                                                            &C::imm8_reg_to_imm8_gpr(ctx, &v840);

14160

                                                        let v852 = constructor_x64_shr(

14161

                                                            ctx, I64, v851, v841,

14162

);

14163

                                                        let v853 =

14164

                                                            constructor_output_gpr(ctx, v852);

14165

                                                        // Rule at src/isa/x64/lower.isle line 1814.

14166

                                                        return Some(v853);

14167

14168

                                                    _ => {}

14169

14170

14171

14172

14173

14174

14175

14176

                        let v823 = C::unpack_value_array_2(ctx, v821);

14177

                        let v826 = C::value_type(ctx, v823.0);

14178

                        let v874 = C::ty_vec128(ctx, v826);

14179

                        if let Some(v875) = v874 {

14180

                            let v876 = constructor_put_in_xmm(ctx, v823.0);

14181

                            let v877 = &C::put_in_xmm_mem(ctx, v823.1);

14182

                            let v884 = constructor_x64_pcmpgt(ctx, v875, v876, v877);

14183

                            let v885 = constructor_output_xmm(ctx, v884);

14184

                            // Rule at src/isa/x64/lower.isle line 1858.

14185

                            return Some(v885);

14186

14187

14188

                    &IntCC::SignedGreaterThanOrEqual => {

14189

                        let v1 = C::first_result(ctx, arg0);

14190

                        if let Some(v2) = v1 {

14191

                            let v3 = C::value_type(ctx, v2);

14192

                            if v3 == I8 {

14193

                                let v823 = C::unpack_value_array_2(ctx, v821);

14194

                                let v826 = C::value_type(ctx, v823.0);

14195

                                match v826 {

14196

                                    I32 => {

14197

                                        let v832 = C::def_inst(ctx, v823.1);

14198

                                        if let Some(v833) = v832 {

14199

                                            let v834 = &C::inst_data(ctx, v833);

14200

                                            if let &InstructionData::UnaryImm {

14201

                                                opcode: ref v835,

14202

                                                imm: v836,

14203

                                            } = v834

14204

14205

                                                if let &Opcode::Iconst = v835 {

14206

                                                    let v837 = C::u64_from_imm64(ctx, v836);

14207

                                                    if v837 == 0x0 {

14208

                                                        let v838 =

14209

                                                            constructor_put_in_gpr(ctx, v823.0);

14210

                                                        let v858 =

14211

                                                            constructor_x64_not(ctx, I64, v838);

14212

                                                        let v863 = Imm8Reg::Imm8 { imm: 0x1F };

14213

                                                        let v869 =

14214

                                                            &C::imm8_reg_to_imm8_gpr(ctx, &v863);

14215

                                                        let v872 = constructor_x64_shr(

14216

                                                            ctx, I32, v858, v869,

14217

);

14218

                                                        let v873 =

14219

                                                            constructor_output_gpr(ctx, v872);

14220

                                                        // Rule at src/isa/x64/lower.isle line 1838.

14221

                                                        return Some(v873);

14222

14223

14224

14225

14226

14227

                                    I64 => {

14228

                                        let v832 = C::def_inst(ctx, v823.1);

14229

                                        if let Some(v833) = v832 {

14230

                                            let v834 = &C::inst_data(ctx, v833);

14231

                                            if let &InstructionData::UnaryImm {

14232

                                                opcode: ref v835,

14233

                                                imm: v836,

14234

                                            } = v834

14235

14236

                                                if let &Opcode::Iconst = v835 {

14237

                                                    let v837 = C::u64_from_imm64(ctx, v836);

14238

                                                    if v837 == 0x0 {

14239

                                                        let v838 =

14240

                                                            constructor_put_in_gpr(ctx, v823.0);

14241

                                                        let v858 =

14242

                                                            constructor_x64_not(ctx, I64, v838);

14243

                                                        let v840 = Imm8Reg::Imm8 { imm: 0x3F };

14244

                                                        let v855 =

14245

                                                            &C::imm8_reg_to_imm8_gpr(ctx, &v840);

14246

                                                        let v859 = constructor_x64_shr(

14247

                                                            ctx, I64, v858, v855,

14248

);

14249

                                                        let v860 =

14250

                                                            constructor_output_gpr(ctx, v859);

14251

                                                        // Rule at src/isa/x64/lower.isle line 1822.

14252

                                                        return Some(v860);

14253

14254

14255

14256

14257

14258

                                    _ => {}

14259

14260

14261

14262

                        let v823 = C::unpack_value_array_2(ctx, v821);

14263

                        let v826 = C::value_type(ctx, v823.0);

14264

                        let v874 = C::ty_vec128(ctx, v826);

14265

                        if let Some(v875) = v874 {

14266

                            let v918 = constructor_has_pmaxs(ctx, v875);

14267

                            if v918 == true {

14268

                                let v876 = constructor_put_in_xmm(ctx, v823.0);

14269

                                let v901 = constructor_put_in_xmm(ctx, v823.0);

14270

                                let v919 = &C::put_in_xmm_mem(ctx, v823.1);

14271

                                let v920 = constructor_x64_pmaxs(ctx, v875, v901, v919);

14272

                                let v921 = &C::xmm_to_xmm_mem(ctx, v920);

14273

                                let v922 = constructor_x64_pcmpeq(ctx, v875, v876, v921);

14274

                                let v923 = constructor_output_xmm(ctx, v922);

14275

                                // Rule at src/isa/x64/lower.isle line 1908.

14276

                                return Some(v923);

14277

14278

                            let v886 = constructor_put_in_xmm(ctx, v823.1);

14279

                            let v887 = &C::put_in_xmm_mem(ctx, v823.0);

14280

                            let v888 = constructor_x64_pcmpgt(ctx, v875, v886, v887);

14281

                            let v880 = constructor_vector_all_ones(ctx);

14282

                            let v881 = &C::xmm_to_xmm_mem(ctx, v880);

14283

                            let v924 = constructor_x64_pxor(ctx, v888, v881);

14284

                            let v925 = constructor_output_xmm(ctx, v924);

14285

                            // Rule at src/isa/x64/lower.isle line 1914.

14286

                            return Some(v925);

14287

14288

14289

                    &IntCC::SignedLessThan => {

14290

                        let v1 = C::first_result(ctx, arg0);

14291

                        if let Some(v2) = v1 {

14292

                            let v3 = C::value_type(ctx, v2);

14293

                            if v3 == I8 {

14294

                                let v823 = C::unpack_value_array_2(ctx, v821);

14295

                                let v826 = C::value_type(ctx, v823.0);

14296

                                match v826 {

14297

                                    I32 => {

14298

                                        let v832 = C::def_inst(ctx, v823.1);

14299

                                        if let Some(v833) = v832 {

14300

                                            let v834 = &C::inst_data(ctx, v833);

14301

                                            if let &InstructionData::UnaryImm {

14302

                                                opcode: ref v835,

14303

                                                imm: v836,

14304

                                            } = v834

14305

14306

                                                if let &Opcode::Iconst = v835 {

14307

                                                    let v837 = C::u64_from_imm64(ctx, v836);

14308

                                                    if v837 == 0x0 {

14309

                                                        let v838 =

14310

                                                            constructor_put_in_gpr(ctx, v823.0);

14311

                                                        let v863 = Imm8Reg::Imm8 { imm: 0x1F };

14312

                                                        let v864 =

14313

                                                            &C::imm8_reg_to_imm8_gpr(ctx, &v863);

14314

                                                        let v865 = constructor_x64_shr(

14315

                                                            ctx, I32, v838, v864,

14316

);

14317

                                                        let v866 =

14318

                                                            constructor_output_gpr(ctx, v865);

14319

                                                        // Rule at src/isa/x64/lower.isle line 1826.

14320

                                                        return Some(v866);

14321

14322

14323

14324

14325

14326

                                    I64 => {

14327

                                        let v832 = C::def_inst(ctx, v823.1);

14328

                                        if let Some(v833) = v832 {

14329

                                            let v834 = &C::inst_data(ctx, v833);

14330

                                            if let &InstructionData::UnaryImm {

14331

                                                opcode: ref v835,

14332

                                                imm: v836,

14333

                                            } = v834

14334

14335

                                                if let &Opcode::Iconst = v835 {

14336

                                                    let v837 = C::u64_from_imm64(ctx, v836);

14337

                                                    if v837 == 0x0 {

14338

                                                        let v838 =

14339

                                                            constructor_put_in_gpr(ctx, v823.0);

14340

                                                        let v840 = Imm8Reg::Imm8 { imm: 0x3F };

14341

                                                        let v841 =

14342

                                                            &C::imm8_reg_to_imm8_gpr(ctx, &v840);

14343

                                                        let v842 = constructor_x64_shr(

14344

                                                            ctx, I64, v838, v841,

14345

);

14346

                                                        let v843 =

14347

                                                            constructor_output_gpr(ctx, v842);

14348

                                                        // Rule at src/isa/x64/lower.isle line 1810.

14349

                                                        return Some(v843);

14350

14351

14352

14353

14354

14355

                                    _ => {}

14356

14357

14358

14359

                        let v823 = C::unpack_value_array_2(ctx, v821);

14360

                        let v826 = C::value_type(ctx, v823.0);

14361

                        let v874 = C::ty_vec128(ctx, v826);

14362

                        if let Some(v875) = v874 {

14363

                            let v886 = constructor_put_in_xmm(ctx, v823.1);

14364

                            let v887 = &C::put_in_xmm_mem(ctx, v823.0);

14365

                            let v888 = constructor_x64_pcmpgt(ctx, v875, v886, v887);

14366

                            let v889 = constructor_output_xmm(ctx, v888);

14367

                            // Rule at src/isa/x64/lower.isle line 1863.

14368

                            return Some(v889);

14369

14370

14371

                    &IntCC::SignedLessThanOrEqual => {

14372

                        let v1 = C::first_result(ctx, arg0);

14373

                        if let Some(v2) = v1 {

14374

                            let v3 = C::value_type(ctx, v2);

14375

                            if v3 == I8 {

14376

                                let v823 = C::unpack_value_array_2(ctx, v821);

14377

                                let v844 = C::def_inst(ctx, v823.0);

14378

                                if let Some(v845) = v844 {

14379

                                    let v846 = &C::inst_data(ctx, v845);

14380

                                    if let &InstructionData::UnaryImm {

14381

                                        opcode: ref v847,

14382

                                        imm: v848,

14383

                                    } = v846

14384

14385

                                        if let &Opcode::Iconst = v847 {

14386

                                            let v849 = C::u64_from_imm64(ctx, v848);

14387

                                            if v849 == 0x0 {

14388

                                                let v850 = C::value_type(ctx, v823.1);

14389

                                                match v850 {

14390

                                                    I32 => {

14391

                                                        let v851 =

14392

                                                            constructor_put_in_gpr(ctx, v823.1);

14393

                                                        let v854 =

14394

                                                            constructor_x64_not(ctx, I64, v851);

14395

                                                        let v863 = Imm8Reg::Imm8 { imm: 0x1F };

14396

                                                        let v869 =

14397

                                                            &C::imm8_reg_to_imm8_gpr(ctx, &v863);

14398

                                                        let v870 = constructor_x64_shr(

14399

                                                            ctx, I32, v854, v869,

14400

);

14401

                                                        let v871 =

14402

                                                            constructor_output_gpr(ctx, v870);

14403

                                                        // Rule at src/isa/x64/lower.isle line 1834.

14404

                                                        return Some(v871);

14405

14406

                                                    I64 => {

14407

                                                        let v851 =

14408

                                                            constructor_put_in_gpr(ctx, v823.1);

14409

                                                        let v854 =

14410

                                                            constructor_x64_not(ctx, I64, v851);

14411

                                                        let v840 = Imm8Reg::Imm8 { imm: 0x3F };

14412

                                                        let v855 =

14413

                                                            &C::imm8_reg_to_imm8_gpr(ctx, &v840);

14414

                                                        let v856 = constructor_x64_shr(

14415

                                                            ctx, I64, v854, v855,

14416

);

14417

                                                        let v857 =

14418

                                                            constructor_output_gpr(ctx, v856);

14419

                                                        // Rule at src/isa/x64/lower.isle line 1818.

14420

                                                        return Some(v857);

14421

14422

                                                    _ => {}

14423

14424

14425

14426

14427

14428

14429

14430

                        let v823 = C::unpack_value_array_2(ctx, v821);

14431

                        let v826 = C::value_type(ctx, v823.0);

14432

                        let v874 = C::ty_vec128(ctx, v826);

14433

                        if let Some(v875) = v874 {

14434

                            let v926 = constructor_has_pmins(ctx, v875);

14435

                            if v926 == true {

14436

                                let v876 = constructor_put_in_xmm(ctx, v823.0);

14437

                                let v901 = constructor_put_in_xmm(ctx, v823.0);

14438

                                let v919 = &C::put_in_xmm_mem(ctx, v823.1);

14439

                                let v927 = constructor_x64_pmins(ctx, v875, v901, v919);

14440

                                let v928 = &C::xmm_to_xmm_mem(ctx, v927);

14441

                                let v929 = constructor_x64_pcmpeq(ctx, v875, v876, v928);

14442

                                let v930 = constructor_output_xmm(ctx, v929);

14443

                                // Rule at src/isa/x64/lower.isle line 1920.

14444

                                return Some(v930);

14445

14446

                            let v876 = constructor_put_in_xmm(ctx, v823.0);

14447

                            let v877 = &C::put_in_xmm_mem(ctx, v823.1);

14448

                            let v884 = constructor_x64_pcmpgt(ctx, v875, v876, v877);

14449

                            let v880 = constructor_vector_all_ones(ctx);

14450

                            let v881 = &C::xmm_to_xmm_mem(ctx, v880);

14451

                            let v931 = constructor_x64_pxor(ctx, v884, v881);

14452

                            let v932 = constructor_output_xmm(ctx, v931);

14453

                            // Rule at src/isa/x64/lower.isle line 1925.

14454

                            return Some(v932);

14455

14456

14457

                    &IntCC::UnsignedGreaterThan => {

14458

                        let v823 = C::unpack_value_array_2(ctx, v821);

14459

                        let v826 = C::value_type(ctx, v823.0);

14460

                        let v874 = C::ty_vec128(ctx, v826);

14461

                        if let Some(v875) = v874 {

14462

                            let v890 = constructor_has_pmaxu(ctx, v875);

14463

                            if v890 == true {

14464

                                let v876 = constructor_put_in_xmm(ctx, v823.0);

14465

                                let v891 = constructor_put_in_xmm(ctx, v823.1);

14466

                                let v892 = &C::xmm_to_xmm_mem(ctx, v891);

14467

                                let v893 = constructor_x64_pmaxu(ctx, v875, v876, v892);

14468

                                let v894 = &C::xmm_to_xmm_mem(ctx, v891);

14469

                                let v895 = constructor_x64_pcmpeq(ctx, v875, v893, v894);

14470

                                let v896 = constructor_vector_all_ones(ctx);

14471

                                let v897 = &C::xmm_to_xmm_mem(ctx, v896);

14472

                                let v898 = constructor_x64_pxor(ctx, v895, v897);

14473

                                let v899 = constructor_output_xmm(ctx, v898);

14474

                                // Rule at src/isa/x64/lower.isle line 1870.

14475

                                return Some(v899);

14476

14477

                            let v900 = constructor_flip_high_bit_mask(ctx, v875);

14478

                            let v901 = constructor_put_in_xmm(ctx, v823.0);

14479

                            let v902 = &C::xmm_to_xmm_mem(ctx, v900);

14480

                            let v903 = constructor_x64_pxor(ctx, v901, v902);

14481

                            let v904 = constructor_put_in_xmm(ctx, v823.1);

14482

                            let v905 = &C::xmm_to_xmm_mem(ctx, v900);

14483

                            let v906 = constructor_x64_pxor(ctx, v904, v905);

14484

                            let v907 = &C::xmm_to_xmm_mem(ctx, v906);

14485

                            let v908 = constructor_x64_pcmpgt(ctx, v875, v903, v907);

14486

                            let v909 = constructor_output_xmm(ctx, v908);

14487

                            // Rule at src/isa/x64/lower.isle line 1880.

14488

                            return Some(v909);

14489

14490

14491

                    &IntCC::UnsignedGreaterThanOrEqual => {

14492

                        let v823 = C::unpack_value_array_2(ctx, v821);

14493

                        let v826 = C::value_type(ctx, v823.0);

14494

                        let v874 = C::ty_vec128(ctx, v826);

14495

                        if let Some(v875) = v874 {

14496

                            let v890 = constructor_has_pmaxu(ctx, v875);

14497

                            if v890 == true {

14498

                                let v876 = constructor_put_in_xmm(ctx, v823.0);

14499

                                let v901 = constructor_put_in_xmm(ctx, v823.0);

14500

                                let v919 = &C::put_in_xmm_mem(ctx, v823.1);

14501

                                let v933 = constructor_x64_pmaxu(ctx, v875, v901, v919);

14502

                                let v934 = &C::xmm_to_xmm_mem(ctx, v933);

14503

                                let v935 = constructor_x64_pcmpeq(ctx, v875, v876, v934);

14504

                                let v936 = constructor_output_xmm(ctx, v935);

14505

                                // Rule at src/isa/x64/lower.isle line 1930.

14506

                                return Some(v936);

14507

14508

14509

                        if v826 == I16X8 {

14510

                            let v886 = constructor_put_in_xmm(ctx, v823.1);

14511

                            let v887 = &C::put_in_xmm_mem(ctx, v823.0);

14512

                            let v937 = constructor_x64_psubusw(ctx, v886, v887);

14513

                            let v938 = constructor_xmm_zero(ctx, I16X8);

14514

                            let v939 = &C::xmm_to_xmm_mem(ctx, v938);

14515

                            let v940 = constructor_x64_pcmpeqw(ctx, v937, v939);

14516

                            let v941 = constructor_output_xmm(ctx, v940);

14517

                            // Rule at src/isa/x64/lower.isle line 1936.

14518

                            return Some(v941);

14519

14520

                        if let Some(v875) = v874 {

14521

                            let v900 = constructor_flip_high_bit_mask(ctx, v875);

14522

                            let v901 = constructor_put_in_xmm(ctx, v823.0);

14523

                            let v902 = &C::xmm_to_xmm_mem(ctx, v900);

14524

                            let v903 = constructor_x64_pxor(ctx, v901, v902);

14525

                            let v904 = constructor_put_in_xmm(ctx, v823.1);

14526

                            let v905 = &C::xmm_to_xmm_mem(ctx, v900);

14527

                            let v906 = constructor_x64_pxor(ctx, v904, v905);

14528

                            let v915 = &C::xmm_to_xmm_mem(ctx, v903);

14529

                            let v916 = constructor_x64_pcmpgt(ctx, v875, v906, v915);

14530

                            let v942 = constructor_vector_all_ones(ctx);

14531

                            let v943 = &C::xmm_to_xmm_mem(ctx, v942);

14532

                            let v944 = constructor_x64_pxor(ctx, v916, v943);

14533

                            let v945 = constructor_output_xmm(ctx, v944);

14534

                            // Rule at src/isa/x64/lower.isle line 1942.

14535

                            return Some(v945);

14536

14537

14538

                    &IntCC::UnsignedLessThan => {

14539

                        let v823 = C::unpack_value_array_2(ctx, v821);

14540

                        let v826 = C::value_type(ctx, v823.0);

14541

                        let v874 = C::ty_vec128(ctx, v826);

14542

                        if let Some(v875) = v874 {

14543

                            let v910 = constructor_has_pminu(ctx, v875);

14544

                            if v910 == true {

14545

                                let v876 = constructor_put_in_xmm(ctx, v823.0);

14546

                                let v891 = constructor_put_in_xmm(ctx, v823.1);

14547

                                let v892 = &C::xmm_to_xmm_mem(ctx, v891);

14548

                                let v911 = constructor_x64_pminu(ctx, v875, v876, v892);

14549

                                let v894 = &C::xmm_to_xmm_mem(ctx, v891);

14550

                                let v912 = constructor_x64_pcmpeq(ctx, v875, v911, v894);

14551

                                let v896 = constructor_vector_all_ones(ctx);

14552

                                let v897 = &C::xmm_to_xmm_mem(ctx, v896);

14553

                                let v913 = constructor_x64_pxor(ctx, v912, v897);

14554

                                let v914 = constructor_output_xmm(ctx, v913);

14555

                                // Rule at src/isa/x64/lower.isle line 1888.

14556

                                return Some(v914);

14557

14558

                            let v900 = constructor_flip_high_bit_mask(ctx, v875);

14559

                            let v901 = constructor_put_in_xmm(ctx, v823.0);

14560

                            let v902 = &C::xmm_to_xmm_mem(ctx, v900);

14561

                            let v903 = constructor_x64_pxor(ctx, v901, v902);

14562

                            let v904 = constructor_put_in_xmm(ctx, v823.1);

14563

                            let v905 = &C::xmm_to_xmm_mem(ctx, v900);

14564

                            let v906 = constructor_x64_pxor(ctx, v904, v905);

14565

                            let v915 = &C::xmm_to_xmm_mem(ctx, v903);

14566

                            let v916 = constructor_x64_pcmpgt(ctx, v875, v906, v915);

14567

                            let v917 = constructor_output_xmm(ctx, v916);

14568

                            // Rule at src/isa/x64/lower.isle line 1899.

14569

                            return Some(v917);

14570

14571

14572

                    &IntCC::UnsignedLessThanOrEqual => {

14573

                        let v823 = C::unpack_value_array_2(ctx, v821);

14574

                        let v826 = C::value_type(ctx, v823.0);

14575

                        let v874 = C::ty_vec128(ctx, v826);

14576

                        if let Some(v875) = v874 {

14577

                            let v910 = constructor_has_pminu(ctx, v875);

14578

                            if v910 == true {

14579

                                let v876 = constructor_put_in_xmm(ctx, v823.0);

14580

                                let v901 = constructor_put_in_xmm(ctx, v823.0);

14581

                                let v919 = &C::put_in_xmm_mem(ctx, v823.1);

14582

                                let v946 = constructor_x64_pminu(ctx, v875, v901, v919);

14583

                                let v947 = &C::xmm_to_xmm_mem(ctx, v946);

14584

                                let v948 = constructor_x64_pcmpeq(ctx, v875, v876, v947);

14585

                                let v949 = constructor_output_xmm(ctx, v948);

14586

                                // Rule at src/isa/x64/lower.isle line 1953.

14587

                                return Some(v949);

14588

14589

14590

                        if v826 == I16X8 {

14591

                            let v876 = constructor_put_in_xmm(ctx, v823.0);

14592

                            let v877 = &C::put_in_xmm_mem(ctx, v823.1);

14593

                            let v950 = constructor_x64_psubusw(ctx, v876, v877);

14594

                            let v951 = constructor_xmm_zero(ctx, I8X16);

14595

                            let v952 = &C::xmm_to_xmm_mem(ctx, v951);

14596

                            let v953 = constructor_x64_pcmpeqw(ctx, v950, v952);

14597

                            let v954 = constructor_output_xmm(ctx, v953);

14598

                            // Rule at src/isa/x64/lower.isle line 1960.

14599

                            return Some(v954);

14600

14601

                        if let Some(v875) = v874 {

14602

                            let v900 = constructor_flip_high_bit_mask(ctx, v875);

14603

                            let v901 = constructor_put_in_xmm(ctx, v823.0);

14604

                            let v902 = &C::xmm_to_xmm_mem(ctx, v900);

14605

                            let v903 = constructor_x64_pxor(ctx, v901, v902);

14606

                            let v904 = constructor_put_in_xmm(ctx, v823.1);

14607

                            let v905 = &C::xmm_to_xmm_mem(ctx, v900);

14608

                            let v906 = constructor_x64_pxor(ctx, v904, v905);

14609

                            let v907 = &C::xmm_to_xmm_mem(ctx, v906);

14610

                            let v908 = constructor_x64_pcmpgt(ctx, v875, v903, v907);

14611

                            let v942 = constructor_vector_all_ones(ctx);

14612

                            let v943 = &C::xmm_to_xmm_mem(ctx, v942);

14613

                            let v955 = constructor_x64_pxor(ctx, v908, v943);

14614

                            let v956 = constructor_output_xmm(ctx, v955);

14615

                            // Rule at src/isa/x64/lower.isle line 1968.

14616

                            return Some(v956);

14617

14618

14619

                    _ => {}

14620

14621

                let v823 = C::unpack_value_array_2(ctx, v821);

14622

                let v826 = C::value_type(ctx, v823.0);

14623

                if v826 == I128 {

14624

                    let v829 = &constructor_emit_cmp(ctx, v822, v823.0, v823.1);

14625

                    let v830 = constructor_lower_icmp_bool(ctx, v829);

14626

                    let v831 = C::output(ctx, v830);

14627

                    // Rule at src/isa/x64/lower.isle line 1806.

14628

                    return Some(v831);

14629

14630

                let v827 = C::fits_in_64(ctx, v826);

14631

                if let Some(v828) = v827 {

14632

                    let v829 = &constructor_emit_cmp(ctx, v822, v823.0, v823.1);

14633

                    let v830 = constructor_lower_icmp_bool(ctx, v829);

14634

                    let v831 = C::output(ctx, v830);

14635

                    // Rule at src/isa/x64/lower.isle line 1803.

14636

                    return Some(v831);

14637

14638

14639

14640

        &InstructionData::Load {

14641

            opcode: ref v1476,

14642

            arg: v1477,

14643

            flags: v1478,

14644

            offset: v1479,

14645

        } => {

14646

            match v1476 {

14647

                &Opcode::Load => {

14648

                    let v1 = C::first_result(ctx, arg0);

14649

                    if let Some(v2) = v1 {

14650

                        let v3 = C::value_type(ctx, v2);

14651

                        match v3 {

14652

                            F32 => {

14653

                                let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14654

                                let v1508 = &C::amode_to_synthetic_amode(ctx, v1489);

14655

                                let v1509 = constructor_x64_movss_load(ctx, v1508);

14656

                                let v1510 = constructor_output_xmm(ctx, v1509);

14657

                                // Rule at src/isa/x64/lower.isle line 2863.

14658

                                return Some(v1510);

14659

14660

                            F64 => {

14661

                                let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14662

                                let v1508 = &C::amode_to_synthetic_amode(ctx, v1489);

14663

                                let v1511 = constructor_x64_movsd_load(ctx, v1508);

14664

                                let v1512 = constructor_output_xmm(ctx, v1511);

14665

                                // Rule at src/isa/x64/lower.isle line 2865.

14666

                                return Some(v1512);

14667

14668

                            F32X4 => {

14669

                                let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14670

                                let v1508 = &C::amode_to_synthetic_amode(ctx, v1489);

14671

                                let v1513 = constructor_x64_movups_load(ctx, v1508);

14672

                                let v1514 = constructor_output_xmm(ctx, v1513);

14673

                                // Rule at src/isa/x64/lower.isle line 2867.

14674

                                return Some(v1514);

14675

14676

                            F64X2 => {

14677

                                let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14678

                                let v1508 = &C::amode_to_synthetic_amode(ctx, v1489);

14679

                                let v1515 = constructor_x64_movupd_load(ctx, v1508);

14680

                                let v1516 = constructor_output_xmm(ctx, v1515);

14681

                                // Rule at src/isa/x64/lower.isle line 2869.

14682

                                return Some(v1516);

14683

14684

                            _ => {}

14685

14686

                        let v1487 = C::ty_int_ref_64(ctx, v3);

14687

                        if let Some(v1488) = v1487 {

14688

                            let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14689

                            let v1490 = constructor_x64_mov(ctx, v1489);

14690

                            let v1491 = constructor_output_reg(ctx, v1490);

14691

                            // Rule at src/isa/x64/lower.isle line 2841.

14692

                            return Some(v1491);

14693

14694

                        let v740 = C::ty_vec128(ctx, v3);

14695

                        if let Some(v741) = v740 {

14696

                            let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14697

                            let v1517 = &constructor_amode_to_xmm_mem(ctx, v1489);

14698

                            let v1518 = constructor_x64_movdqu_load(ctx, v1517);

14699

                            let v1519 = constructor_output_xmm(ctx, v1518);

14700

                            // Rule at src/isa/x64/lower.isle line 2871.

14701

                            return Some(v1519);

14702

14703

                        if v3 == I128 {

14704

                            let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14705

                            let v1521 = &C::amode_offset(ctx, v1489, 0x8);

14706

                            let v1522 = constructor_x64_mov(ctx, v1489);

14707

                            let v1523 = constructor_x64_mov(ctx, v1521);

14708

                            let v1524 = C::value_regs(ctx, v1522, v1523);

14709

                            let v1525 = C::output(ctx, v1524);

14710

                            // Rule at src/isa/x64/lower.isle line 2875.

14711

                            return Some(v1525);

14712

14713

                        let v1233 = C::fits_in_32(ctx, v3);

14714

                        if let Some(v1234) = v1233 {

14715

                            let v1473 = &C::type_register_class(ctx, v3);

14716

                            if let Some(v1474) = v1473 {

14717

                                if let &RegisterClass::Gpr {

14718

                                    single_register: v1475,

14719

                                } = v1474

14720

14721

                                    let v1480 = C::ty_bits_u16(ctx, v1234);

14722

                                    let v1482 = &C::ext_mode(ctx, v1480, 0x40);

14723

                                    let v1483 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14724

                                    let v1484 = &constructor_amode_to_gpr_mem(ctx, v1483);

14725

                                    let v1485 = constructor_x64_movzx(ctx, v1482, v1484);

14726

                                    let v1486 = constructor_output_gpr(ctx, v1485);

14727

                                    // Rule at src/isa/x64/lower.isle line 2837.

14728

                                    return Some(v1486);

14729

14730

14731

14732

14733

14734

                &Opcode::Uload8 => {

14735

                    let v1 = C::first_result(ctx, arg0);

14736

                    if let Some(v2) = v1 {

14737

                        let v3 = C::value_type(ctx, v2);

14738

                        let v1473 = &C::type_register_class(ctx, v3);

14739

                        if let Some(v1474) = v1473 {

14740

                            if let &RegisterClass::Gpr {

14741

                                single_register: v1475,

14742

                            } = v1474

14743

14744

                                let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14745

                                let v1493 = &constructor_amode_to_gpr_mem(ctx, v1489);

14746

                                let v1494 = constructor_x64_movzx(ctx, &ExtMode::BQ, v1493);

14747

                                let v1495 = constructor_output_gpr(ctx, v1494);

14748

                                // Rule at src/isa/x64/lower.isle line 2846.

14749

                                return Some(v1495);

14750

14751

14752

14753

14754

                &Opcode::Sload8 => {

14755

                    let v1 = C::first_result(ctx, arg0);

14756

                    if let Some(v2) = v1 {

14757

                        let v3 = C::value_type(ctx, v2);

14758

                        let v1473 = &C::type_register_class(ctx, v3);

14759

                        if let Some(v1474) = v1473 {

14760

                            if let &RegisterClass::Gpr {

14761

                                single_register: v1475,

14762

                            } = v1474

14763

14764

                                let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14765

                                let v1493 = &constructor_amode_to_gpr_mem(ctx, v1489);

14766

                                let v1496 = constructor_x64_movsx(ctx, &ExtMode::BQ, v1493);

14767

                                let v1497 = constructor_output_gpr(ctx, v1496);

14768

                                // Rule at src/isa/x64/lower.isle line 2848.

14769

                                return Some(v1497);

14770

14771

14772

14773

14774

                &Opcode::Uload16 => {

14775

                    let v1 = C::first_result(ctx, arg0);

14776

                    if let Some(v2) = v1 {

14777

                        let v3 = C::value_type(ctx, v2);

14778

                        let v1473 = &C::type_register_class(ctx, v3);

14779

                        if let Some(v1474) = v1473 {

14780

                            if let &RegisterClass::Gpr {

14781

                                single_register: v1475,

14782

                            } = v1474

14783

14784

                                let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14785

                                let v1493 = &constructor_amode_to_gpr_mem(ctx, v1489);

14786

                                let v1499 = constructor_x64_movzx(ctx, &ExtMode::WQ, v1493);

14787

                                let v1500 = constructor_output_gpr(ctx, v1499);

14788

                                // Rule at src/isa/x64/lower.isle line 2850.

14789

                                return Some(v1500);

14790

14791

14792

14793

14794

                &Opcode::Sload16 => {

14795

                    let v1 = C::first_result(ctx, arg0);

14796

                    if let Some(v2) = v1 {

14797

                        let v3 = C::value_type(ctx, v2);

14798

                        let v1473 = &C::type_register_class(ctx, v3);

14799

                        if let Some(v1474) = v1473 {

14800

                            if let &RegisterClass::Gpr {

14801

                                single_register: v1475,

14802

                            } = v1474

14803

14804

                                let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14805

                                let v1493 = &constructor_amode_to_gpr_mem(ctx, v1489);

14806

                                let v1501 = constructor_x64_movsx(ctx, &ExtMode::WQ, v1493);

14807

                                let v1502 = constructor_output_gpr(ctx, v1501);

14808

                                // Rule at src/isa/x64/lower.isle line 2852.

14809

                                return Some(v1502);

14810

14811

14812

14813

14814

                &Opcode::Uload32 => {

14815

                    let v1 = C::first_result(ctx, arg0);

14816

                    if let Some(v2) = v1 {

14817

                        let v3 = C::value_type(ctx, v2);

14818

                        let v1473 = &C::type_register_class(ctx, v3);

14819

                        if let Some(v1474) = v1473 {

14820

                            if let &RegisterClass::Gpr {

14821

                                single_register: v1475,

14822

                            } = v1474

14823

14824

                                let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14825

                                let v1493 = &constructor_amode_to_gpr_mem(ctx, v1489);

14826

                                let v1504 = constructor_x64_movzx(ctx, &ExtMode::LQ, v1493);

14827

                                let v1505 = constructor_output_gpr(ctx, v1504);

14828

                                // Rule at src/isa/x64/lower.isle line 2854.

14829

                                return Some(v1505);

14830

14831

14832

14833

14834

                &Opcode::Sload32 => {

14835

                    let v1 = C::first_result(ctx, arg0);

14836

                    if let Some(v2) = v1 {

14837

                        let v3 = C::value_type(ctx, v2);

14838

                        let v1473 = &C::type_register_class(ctx, v3);

14839

                        if let Some(v1474) = v1473 {

14840

                            if let &RegisterClass::Gpr {

14841

                                single_register: v1475,

14842

                            } = v1474

14843

14844

                                let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14845

                                let v1493 = &constructor_amode_to_gpr_mem(ctx, v1489);

14846

                                let v1506 = constructor_x64_movsx(ctx, &ExtMode::LQ, v1493);

14847

                                let v1507 = constructor_output_gpr(ctx, v1506);

14848

                                // Rule at src/isa/x64/lower.isle line 2856.

14849

                                return Some(v1507);

14850

14851

14852

14853

14854

                &Opcode::Uload8x8 => {

14855

                    let v1 = C::first_result(ctx, arg0);

14856

                    if let Some(v2) = v1 {

14857

                        let v3 = C::value_type(ctx, v2);

14858

                        if v3 == I16X8 {

14859

                            let v441 = C::use_sse41(ctx);

14860

                            if v441 == true {

14861

                                let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14862

                                let v1517 = &constructor_amode_to_xmm_mem(ctx, v1489);

14863

                                let v1528 = constructor_x64_pmovzxbw(ctx, v1517);

14864

                                let v1529 = constructor_output_xmm(ctx, v1528);

14865

                                // Rule at src/isa/x64/lower.isle line 2888.

14866

                                return Some(v1529);

14867

14868

                            let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14869

                            let v1493 = &constructor_amode_to_gpr_mem(ctx, v1489);

14870

                            let v1538 = constructor_x64_movq_to_xmm(ctx, v1493);

14871

                            let v1541 = constructor_lower_uwiden_low(ctx, I16X8, v1538);

14872

                            let v1542 = constructor_output_xmm(ctx, v1541);

14873

                            // Rule at src/isa/x64/lower.isle line 2906.

14874

                            return Some(v1542);

14875

14876

14877

14878

                &Opcode::Sload8x8 => {

14879

                    let v1 = C::first_result(ctx, arg0);

14880

                    if let Some(v2) = v1 {

14881

                        let v3 = C::value_type(ctx, v2);

14882

                        if v3 == I16X8 {

14883

                            let v441 = C::use_sse41(ctx);

14884

                            if v441 == true {

14885

                                let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14886

                                let v1517 = &constructor_amode_to_xmm_mem(ctx, v1489);

14887

                                let v1526 = constructor_x64_pmovsxbw(ctx, v1517);

14888

                                let v1527 = constructor_output_xmm(ctx, v1526);

14889

                                // Rule at src/isa/x64/lower.isle line 2885.

14890

                                return Some(v1527);

14891

14892

                            let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14893

                            let v1493 = &constructor_amode_to_gpr_mem(ctx, v1489);

14894

                            let v1538 = constructor_x64_movq_to_xmm(ctx, v1493);

14895

                            let v1539 = constructor_lower_swiden_low(ctx, I16X8, v1538);

14896

                            let v1540 = constructor_output_xmm(ctx, v1539);

14897

                            // Rule at src/isa/x64/lower.isle line 2904.

14898

                            return Some(v1540);

14899

14900

14901

14902

                &Opcode::Uload16x4 => {

14903

                    let v1 = C::first_result(ctx, arg0);

14904

                    if let Some(v2) = v1 {

14905

                        let v3 = C::value_type(ctx, v2);

14906

                        if v3 == I32X4 {

14907

                            let v441 = C::use_sse41(ctx);

14908

                            if v441 == true {

14909

                                let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14910

                                let v1517 = &constructor_amode_to_xmm_mem(ctx, v1489);

14911

                                let v1532 = constructor_x64_pmovzxwd(ctx, v1517);

14912

                                let v1533 = constructor_output_xmm(ctx, v1532);

14913

                                // Rule at src/isa/x64/lower.isle line 2894.

14914

                                return Some(v1533);

14915

14916

                            let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14917

                            let v1493 = &constructor_amode_to_gpr_mem(ctx, v1489);

14918

                            let v1538 = constructor_x64_movq_to_xmm(ctx, v1493);

14919

                            let v1545 = constructor_lower_uwiden_low(ctx, I32X4, v1538);

14920

                            let v1546 = constructor_output_xmm(ctx, v1545);

14921

                            // Rule at src/isa/x64/lower.isle line 2910.

14922

                            return Some(v1546);

14923

14924

14925

14926

                &Opcode::Sload16x4 => {

14927

                    let v1 = C::first_result(ctx, arg0);

14928

                    if let Some(v2) = v1 {

14929

                        let v3 = C::value_type(ctx, v2);

14930

                        if v3 == I32X4 {

14931

                            let v441 = C::use_sse41(ctx);

14932

                            if v441 == true {

14933

                                let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14934

                                let v1517 = &constructor_amode_to_xmm_mem(ctx, v1489);

14935

                                let v1530 = constructor_x64_pmovsxwd(ctx, v1517);

14936

                                let v1531 = constructor_output_xmm(ctx, v1530);

14937

                                // Rule at src/isa/x64/lower.isle line 2891.

14938

                                return Some(v1531);

14939

14940

                            let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14941

                            let v1493 = &constructor_amode_to_gpr_mem(ctx, v1489);

14942

                            let v1538 = constructor_x64_movq_to_xmm(ctx, v1493);

14943

                            let v1543 = constructor_lower_swiden_low(ctx, I32X4, v1538);

14944

                            let v1544 = constructor_output_xmm(ctx, v1543);

14945

                            // Rule at src/isa/x64/lower.isle line 2908.

14946

                            return Some(v1544);

14947

14948

14949

14950

                &Opcode::Uload32x2 => {

14951

                    let v1 = C::first_result(ctx, arg0);

14952

                    if let Some(v2) = v1 {

14953

                        let v3 = C::value_type(ctx, v2);

14954

                        if v3 == I64X2 {

14955

                            let v441 = C::use_sse41(ctx);

14956

                            if v441 == true {

14957

                                let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14958

                                let v1517 = &constructor_amode_to_xmm_mem(ctx, v1489);

14959

                                let v1536 = constructor_x64_pmovzxdq(ctx, v1517);

14960

                                let v1537 = constructor_output_xmm(ctx, v1536);

14961

                                // Rule at src/isa/x64/lower.isle line 2900.

14962

                                return Some(v1537);

14963

14964

                            let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14965

                            let v1493 = &constructor_amode_to_gpr_mem(ctx, v1489);

14966

                            let v1538 = constructor_x64_movq_to_xmm(ctx, v1493);

14967

                            let v1549 = constructor_lower_uwiden_low(ctx, I64X2, v1538);

14968

                            let v1550 = constructor_output_xmm(ctx, v1549);

14969

                            // Rule at src/isa/x64/lower.isle line 2914.

14970

                            return Some(v1550);

14971

14972

14973

14974

                &Opcode::Sload32x2 => {

14975

                    let v1 = C::first_result(ctx, arg0);

14976

                    if let Some(v2) = v1 {

14977

                        let v3 = C::value_type(ctx, v2);

14978

                        if v3 == I64X2 {

14979

                            let v441 = C::use_sse41(ctx);

14980

                            if v441 == true {

14981

                                let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14982

                                let v1517 = &constructor_amode_to_xmm_mem(ctx, v1489);

14983

                                let v1534 = constructor_x64_pmovsxdq(ctx, v1517);

14984

                                let v1535 = constructor_output_xmm(ctx, v1534);

14985

                                // Rule at src/isa/x64/lower.isle line 2897.

14986

                                return Some(v1535);

14987

14988

                            let v1489 = &constructor_to_amode(ctx, v1478, v1477, v1479);

14989

                            let v1493 = &constructor_amode_to_gpr_mem(ctx, v1489);

14990

                            let v1538 = constructor_x64_movq_to_xmm(ctx, v1493);

14991

                            let v1547 = constructor_lower_swiden_low(ctx, I64X2, v1538);

14992

                            let v1548 = constructor_output_xmm(ctx, v1547);

14993

                            // Rule at src/isa/x64/lower.isle line 2912.

14994

                            return Some(v1548);

14995

14996

14997

14998

                _ => {}

14999

15000

15001

        &InstructionData::LoadNoOffset {

15002

            opcode: ref v1697,

15003

            arg: v1698,

15004

            flags: v1699,

15005

        } => {

15006

            match v1697 {

15007

                &Opcode::Bitcast => {

15008

                    let v1 = C::first_result(ctx, arg0);

15009

                    if let Some(v2) = v1 {

15010

                        let v3 = C::value_type(ctx, v2);

15011

                        let v1473 = &C::type_register_class(ctx, v3);

15012

                        if let Some(v1474) = v1473 {

15013

                            match v1474 {

15014

                                &RegisterClass::Gpr {

15015

                                    single_register: v1475,

15016

                                } => {

15017

                                    let v2115 = C::value_type(ctx, v1698);

15018

                                    let v2126 = &C::type_register_class(ctx, v2115);

15019

                                    if let Some(v2127) = v2126 {

15020

                                        if let &RegisterClass::Gpr {

15021

                                            single_register: v2128,

15022

                                        } = v2127

15023

15024

                                            let v2129 = constructor_output_value(ctx, v1698);

15025

                                            // Rule at src/isa/x64/lower.isle line 3907.

15026

                                            return Some(v2129);

15027

15028

15029

15030

                                &RegisterClass::Xmm => {

15031

                                    let v2115 = C::value_type(ctx, v1698);

15032

                                    let v2126 = &C::type_register_class(ctx, v2115);

15033

                                    if let Some(v2127) = v2126 {

15034

                                        if let &RegisterClass::Xmm = v2127 {

15035

                                            let v2129 = constructor_output_value(ctx, v1698);

15036

                                            // Rule at src/isa/x64/lower.isle line 3911.

15037

                                            return Some(v2129);

15038

15039

15040

15041

                                _ => {}

15042

15043

15044

                        match v3 {

15045

                            I32 => {

15046

                                let v2115 = C::value_type(ctx, v1698);

15047

                                if v2115 == F32 {

15048

                                    let v2116 = constructor_put_in_xmm(ctx, v1698);

15049

                                    let v2117 = constructor_bitcast_xmm_to_gpr(ctx, F32, v2116);

15050

                                    let v2118 = constructor_output_gpr(ctx, v2117);

15051

                                    // Rule at src/isa/x64/lower.isle line 3894.

15052

                                    return Some(v2118);

15053

15054

15055

                            I64 => {

15056

                                let v2115 = C::value_type(ctx, v1698);

15057

                                if v2115 == F64 {

15058

                                    let v2116 = constructor_put_in_xmm(ctx, v1698);

15059

                                    let v2122 = constructor_bitcast_xmm_to_gpr(ctx, F64, v2116);

15060

                                    let v2123 = constructor_output_gpr(ctx, v2122);

15061

                                    // Rule at src/isa/x64/lower.isle line 3900.

15062

                                    return Some(v2123);

15063

15064

15065

                            F32 => {

15066

                                let v2115 = C::value_type(ctx, v1698);

15067

                                if v2115 == I32 {

15068

                                    let v2119 = constructor_put_in_gpr(ctx, v1698);

15069

                                    let v2120 = constructor_bitcast_gpr_to_xmm(ctx, I32, v2119);

15070

                                    let v2121 = constructor_output_xmm(ctx, v2120);

15071

                                    // Rule at src/isa/x64/lower.isle line 3897.

15072

                                    return Some(v2121);

15073

15074

15075

                            F64 => {

15076

                                let v2115 = C::value_type(ctx, v1698);

15077

                                if v2115 == I64 {

15078

                                    let v2119 = constructor_put_in_gpr(ctx, v1698);

15079

                                    let v2124 = constructor_bitcast_gpr_to_xmm(ctx, I64, v2119);

15080

                                    let v2125 = constructor_output_xmm(ctx, v2124);

15081

                                    // Rule at src/isa/x64/lower.isle line 3903.

15082

                                    return Some(v2125);

15083

15084

15085

                            _ => {}

15086

15087

15088

15089

                &Opcode::AtomicLoad => {

15090

                    let v1 = C::first_result(ctx, arg0);

15091

                    if let Some(v2) = v1 {

15092

                        let v3 = C::value_type(ctx, v2);

15093

                        if v3 == I64 {

15094

                            let v48 = C::zero_offset(ctx);

15095

                            let v1700 = &constructor_to_amode(ctx, v1699, v1698, v48);

15096

                            let v1701 = constructor_x64_mov(ctx, v1700);

15097

                            let v1702 = constructor_output_reg(ctx, v1701);

15098

                            // Rule at src/isa/x64/lower.isle line 3196.

15099

                            return Some(v1702);

15100

15101

                        let v1233 = C::fits_in_32(ctx, v3);

15102

                        if let Some(v1234) = v1233 {

15103

                            let v1703 = C::ty_int(ctx, v3);

15104

                            if let Some(v1704) = v1703 {

15105

                                let v1480 = C::ty_bits_u16(ctx, v1234);

15106

                                let v1482 = &C::ext_mode(ctx, v1480, 0x40);

15107

                                let v1705 = C::zero_offset(ctx);

15108

                                let v1706 = &constructor_to_amode(ctx, v1699, v1698, v1705);

15109

                                let v1707 = &constructor_amode_to_gpr_mem(ctx, v1706);

15110

                                let v1708 = constructor_x64_movzx(ctx, v1482, v1707);

15111

                                let v1709 = constructor_output_gpr(ctx, v1708);

15112

                                // Rule at src/isa/x64/lower.isle line 3198.

15113

                                return Some(v1709);

15114

15115

15116

15117

15118

                _ => {}

15119

15120

15121

        &InstructionData::MultiAry {

15122

            opcode: ref v816,

15123

            args: v817,

15124

        } => {

15125

            if let &Opcode::Return = v816 {

15126

                let v818 = C::value_list_slice(ctx, v817);

15127

                let v819 = constructor_lower_return(ctx, v818);

15128

                // Rule at src/isa/x64/lower.isle line 1798.

15129

                return Some(v819);

15130

15131

15132

        &InstructionData::NullAry { opcode: ref v31 } => {

15133

            match v31 {

15134

                &Opcode::Debugtrap => {

15135

                    let v1247 = &constructor_x64_hlt(ctx);

15136

                    let v1248 = constructor_side_effect(ctx, v1247);

15137

                    // Rule at src/isa/x64/lower.isle line 2479.

15138

                    return Some(v1248);

15139

15140

                &Opcode::GetPinnedReg => {

15141

                    let v2238 = constructor_read_pinned_gpr(ctx);

15142

                    let v2239 = constructor_output_gpr(ctx, v2238);

15143

                    // Rule at src/isa/x64/lower.isle line 4172.

15144

                    return Some(v2239);

15145

15146

                &Opcode::GetFramePointer => {

15147

                    let v1775 = constructor_x64_rbp(ctx);

15148

                    let v1776 = constructor_output_reg(ctx, v1775);

15149

                    // Rule at src/isa/x64/lower.isle line 3253.

15150

                    return Some(v1776);

15151

15152

                &Opcode::GetStackPointer => {

15153

                    let v1777 = constructor_x64_rsp(ctx);

15154

                    let v1778 = constructor_output_reg(ctx, v1777);

15155

                    // Rule at src/isa/x64/lower.isle line 3256.

15156

                    return Some(v1778);

15157

15158

                &Opcode::GetReturnAddress => {

15159

                    let v1775 = constructor_x64_rbp(ctx);

15160

                    let v47 = C::mem_flags_trusted(ctx);

15161

                    let v1779 = Amode::ImmReg {

15162

                        simm32: 0x8,

15163

                        base: v1775,

15164

                        flags: v47,

15165

};

15166

                    let v1780 = &C::amode_to_synthetic_amode(ctx, &v1779);

15167

                    let v1781 = constructor_x64_load(ctx, I64, v1780, &ExtKind::None);

15168

                    let v1782 = constructor_output_reg(ctx, v1781);

15169

                    // Rule at src/isa/x64/lower.isle line 3259.

15170

                    return Some(v1782);

15171

15172

                &Opcode::Null => {

15173

                    let v1 = C::first_result(ctx, arg0);

15174

                    if let Some(v2) = v1 {

15175

                        let v3 = C::value_type(ctx, v2);

15176

                        let v32 = constructor_imm(ctx, v3, 0x0);

15177

                        let v33 = constructor_output_reg(ctx, v32);

15178

                        // Rule at src/isa/x64/lower.isle line 37.

15179

                        return Some(v33);

15180

15181

15182

                &Opcode::Nop => {

15183

                    let v2592 = C::invalid_reg(ctx);

15184

                    let v2593 = constructor_output_reg(ctx, v2592);

15185

                    // Rule at src/isa/x64/lower.isle line 4719.

15186

                    return Some(v2593);

15187

15188

                &Opcode::Fence => {

15189

                    let v1677 = &constructor_x64_mfence(ctx);

15190

                    let v1678 = constructor_side_effect(ctx, v1677);

15191

                    // Rule at src/isa/x64/lower.isle line 3174.

15192

                    return Some(v1678);

15193

15194

                _ => {}

15195

15196

15197

        &InstructionData::Shuffle {

15198

            opcode: ref v2247,

15199

            args: ref v2248,

15200

            imm: v2249,

15201

        } => {

15202

            if let &Opcode::Shuffle = v2247 {

15203

                let v441 = C::use_sse41(ctx);

15204

                if v441 == true {

15205

                    let v2253 = C::pblendw_imm(ctx, v2249);

15206

                    if let Some(v2254) = v2253 {

15207

                        let v2250 = C::unpack_value_array_2(ctx, v2248);

15208

                        let v2255 = constructor_put_in_xmm(ctx, v2250.0);

15209

                        let v2256 = &C::put_in_xmm_mem(ctx, v2250.1);

15210

                        let v2257 = constructor_x64_pblendw(ctx, v2255, v2256, v2254);

15211

                        let v2258 = constructor_output_xmm(ctx, v2257);

15212

                        // Rule at src/isa/x64/lower.isle line 4192.

15213

                        return Some(v2258);

15214

15215

15216

                let v525 = C::use_ssse3(ctx);

15217

                if v525 == true {

15218

                    let v2259 = C::palignr_imm_from_immediate(ctx, v2249);

15219

                    if let Some(v2260) = v2259 {

15220

                        let v2250 = C::unpack_value_array_2(ctx, v2248);

15221

                        let v2261 = constructor_put_in_xmm(ctx, v2250.1);

15222

                        let v2262 = &C::put_in_xmm_mem(ctx, v2250.0);

15223

                        let v2263 = constructor_x64_palignr(ctx, v2261, v2262, v2260);

15224

                        let v2264 = constructor_output_xmm(ctx, v2263);

15225

                        // Rule at src/isa/x64/lower.isle line 4203.

15226

                        return Some(v2264);

15227

15228

15229

                let v2265 = C::pshuflw_lhs_imm(ctx, v2249);

15230

                if let Some(v2266) = v2265 {

15231

                    let v2250 = C::unpack_value_array_2(ctx, v2248);

15232

                    let v2267 = &C::put_in_xmm_mem(ctx, v2250.0);

15233

                    let v2268 = constructor_x64_pshuflw(ctx, v2267, v2266);

15234

                    let v2269 = constructor_output_xmm(ctx, v2268);

15235

                    // Rule at src/isa/x64/lower.isle line 4215.

15236

                    return Some(v2269);

15237

15238

                let v2270 = C::pshuflw_rhs_imm(ctx, v2249);

15239

                if let Some(v2271) = v2270 {

15240

                    let v2250 = C::unpack_value_array_2(ctx, v2248);

15241

                    let v2272 = &C::put_in_xmm_mem(ctx, v2250.1);

15242

                    let v2273 = constructor_x64_pshuflw(ctx, v2272, v2271);

15243

                    let v2274 = constructor_output_xmm(ctx, v2273);

15244

                    // Rule at src/isa/x64/lower.isle line 4217.

15245

                    return Some(v2274);

15246

15247

                let v2275 = C::pshufhw_lhs_imm(ctx, v2249);

15248

                if let Some(v2276) = v2275 {

15249

                    let v2250 = C::unpack_value_array_2(ctx, v2248);

15250

                    let v2267 = &C::put_in_xmm_mem(ctx, v2250.0);

15251

                    let v2277 = constructor_x64_pshufhw(ctx, v2267, v2276);

15252

                    let v2278 = constructor_output_xmm(ctx, v2277);

15253

                    // Rule at src/isa/x64/lower.isle line 4219.

15254

                    return Some(v2278);

15255

15256

                let v2279 = C::pshufhw_rhs_imm(ctx, v2249);

15257

                if let Some(v2280) = v2279 {

15258

                    let v2250 = C::unpack_value_array_2(ctx, v2248);

15259

                    let v2272 = &C::put_in_xmm_mem(ctx, v2250.1);

15260

                    let v2281 = constructor_x64_pshufhw(ctx, v2272, v2280);

15261

                    let v2282 = constructor_output_xmm(ctx, v2281);

15262

                    // Rule at src/isa/x64/lower.isle line 4221.

15263

                    return Some(v2282);

15264

15265

                let v2283 = C::pshufd_lhs_imm(ctx, v2249);

15266

                if let Some(v2284) = v2283 {

15267

                    let v2250 = C::unpack_value_array_2(ctx, v2248);

15268

                    let v2267 = &C::put_in_xmm_mem(ctx, v2250.0);

15269

                    let v2285 = constructor_x64_pshufd(ctx, v2267, v2284);

15270

                    let v2286 = constructor_output_xmm(ctx, v2285);

15271

                    // Rule at src/isa/x64/lower.isle line 4238.

15272

                    return Some(v2286);

15273

15274

                let v2287 = C::pshufd_rhs_imm(ctx, v2249);

15275

                if let Some(v2288) = v2287 {

15276

                    let v2250 = C::unpack_value_array_2(ctx, v2248);

15277

                    let v2272 = &C::put_in_xmm_mem(ctx, v2250.1);

15278

                    let v2289 = constructor_x64_pshufd(ctx, v2272, v2288);

15279

                    let v2290 = constructor_output_xmm(ctx, v2289);

15280

                    // Rule at src/isa/x64/lower.isle line 4240.

15281

                    return Some(v2290);

15282

15283

                let v2291 = C::u128_from_immediate(ctx, v2249);

15284

                if let Some(v2292) = v2291 {

15285

                    match v2292 {

15286

                        0x0 => {

15287

                            if v525 == true {

15288

                                let v2250 = C::unpack_value_array_2(ctx, v2248);

15289

                                let v2255 = constructor_put_in_xmm(ctx, v2250.0);

15290

                                let v530 = constructor_xmm_zero(ctx, I8X16);

15291

                                let v2073 = &C::xmm_to_xmm_mem(ctx, v530);

15292

                                let v2309 = constructor_x64_pshufb(ctx, v2255, v2073);

15293

                                let v2310 = constructor_output_xmm(ctx, v2309);

15294

                                // Rule at src/isa/x64/lower.isle line 4277.

15295

                                return Some(v2310);

15296

15297

15298

                        0x17071606150514041303120211011000 => {

15299

                            let v2250 = C::unpack_value_array_2(ctx, v2248);

15300

                            let v2255 = constructor_put_in_xmm(ctx, v2250.0);

15301

                            let v2256 = &C::put_in_xmm_mem(ctx, v2250.1);

15302

                            let v2295 = constructor_x64_punpcklbw(ctx, v2255, v2256);

15303

                            let v2296 = constructor_output_xmm(ctx, v2295);

15304

                            // Rule at src/isa/x64/lower.isle line 4251.

15305

                            return Some(v2296);

15306

15307

                        0x17160706151405041312030211100100 => {

15308

                            let v2250 = C::unpack_value_array_2(ctx, v2248);

15309

                            let v2255 = constructor_put_in_xmm(ctx, v2250.0);

15310

                            let v2256 = &C::put_in_xmm_mem(ctx, v2250.1);

15311

                            let v2299 = constructor_x64_punpcklwd(ctx, v2255, v2256);

15312

                            let v2300 = constructor_output_xmm(ctx, v2299);

15313

                            // Rule at src/isa/x64/lower.isle line 4257.

15314

                            return Some(v2300);

15315

15316

                        0x17161514070605041312111003020100 => {

15317

                            let v2250 = C::unpack_value_array_2(ctx, v2248);

15318

                            let v2255 = constructor_put_in_xmm(ctx, v2250.0);

15319

                            let v2256 = &C::put_in_xmm_mem(ctx, v2250.1);

15320

                            let v2303 = constructor_x64_punpckldq(ctx, v2255, v2256);

15321

                            let v2304 = constructor_output_xmm(ctx, v2303);

15322

                            // Rule at src/isa/x64/lower.isle line 4263.

15323

                            return Some(v2304);

15324

15325

                        0x17161514131211100706050403020100 => {

15326

                            let v2250 = C::unpack_value_array_2(ctx, v2248);

15327

                            let v2255 = constructor_put_in_xmm(ctx, v2250.0);

15328

                            let v2256 = &C::put_in_xmm_mem(ctx, v2250.1);

15329

                            let v2307 = constructor_x64_punpcklqdq(ctx, v2255, v2256);

15330

                            let v2308 = constructor_output_xmm(ctx, v2307);

15331

                            // Rule at src/isa/x64/lower.isle line 4269.

15332

                            return Some(v2308);

15333

15334

                        0x1F0F1E0E1D0D1C0C1B0B1A0A19091808 => {

15335

                            let v2250 = C::unpack_value_array_2(ctx, v2248);

15336

                            let v2255 = constructor_put_in_xmm(ctx, v2250.0);

15337

                            let v2256 = &C::put_in_xmm_mem(ctx, v2250.1);

15338

                            let v2293 = constructor_x64_punpckhbw(ctx, v2255, v2256);

15339

                            let v2294 = constructor_output_xmm(ctx, v2293);

15340

                            // Rule at src/isa/x64/lower.isle line 4249.

15341

                            return Some(v2294);

15342

15343

                        0x1F1E0F0E1D1C0D0C1B1A0B0A19180908 => {

15344

                            let v2250 = C::unpack_value_array_2(ctx, v2248);

15345

                            let v2255 = constructor_put_in_xmm(ctx, v2250.0);

15346

                            let v2256 = &C::put_in_xmm_mem(ctx, v2250.1);

15347

                            let v2297 = constructor_x64_punpckhwd(ctx, v2255, v2256);

15348

                            let v2298 = constructor_output_xmm(ctx, v2297);

15349

                            // Rule at src/isa/x64/lower.isle line 4255.

15350

                            return Some(v2298);

15351

15352

                        0x1F1E1D1C0F0E0D0C1B1A19180B0A0908 => {

15353

                            let v2250 = C::unpack_value_array_2(ctx, v2248);

15354

                            let v2255 = constructor_put_in_xmm(ctx, v2250.0);

15355

                            let v2256 = &C::put_in_xmm_mem(ctx, v2250.1);

15356

                            let v2301 = constructor_x64_punpckhdq(ctx, v2255, v2256);

15357

                            let v2302 = constructor_output_xmm(ctx, v2301);

15358

                            // Rule at src/isa/x64/lower.isle line 4261.

15359

                            return Some(v2302);

15360

15361

                        0x1F1E1D1C1B1A19180F0E0D0C0B0A0908 => {

15362

                            let v2250 = C::unpack_value_array_2(ctx, v2248);

15363

                            let v2255 = constructor_put_in_xmm(ctx, v2250.0);

15364

                            let v2256 = &C::put_in_xmm_mem(ctx, v2250.1);

15365

                            let v2305 = constructor_x64_punpckhqdq(ctx, v2255, v2256);

15366

                            let v2306 = constructor_output_xmm(ctx, v2305);

15367

                            // Rule at src/isa/x64/lower.isle line 4267.

15368

                            return Some(v2306);

15369

15370

                        _ => {}

15371

15372

15373

                let v2311 = C::shufps_imm(ctx, v2249);

15374

                if let Some(v2312) = v2311 {

15375

                    let v2250 = C::unpack_value_array_2(ctx, v2248);

15376

                    let v2255 = constructor_put_in_xmm(ctx, v2250.0);

15377

                    let v2256 = &C::put_in_xmm_mem(ctx, v2250.1);

15378

                    let v2313 = constructor_x64_shufps(ctx, v2255, v2256, v2312);

15379

                    let v2314 = constructor_output_xmm(ctx, v2313);

15380

                    // Rule at src/isa/x64/lower.isle line 4291.

15381

                    return Some(v2314);

15382

15383

                let v2315 = C::shufps_rev_imm(ctx, v2249);

15384

                if let Some(v2316) = v2315 {

15385

                    let v2250 = C::unpack_value_array_2(ctx, v2248);

15386

                    let v2261 = constructor_put_in_xmm(ctx, v2250.1);

15387

                    let v2262 = &C::put_in_xmm_mem(ctx, v2250.0);

15388

                    let v2317 = constructor_x64_shufps(ctx, v2261, v2262, v2316);

15389

                    let v2318 = constructor_output_xmm(ctx, v2317);

15390

                    // Rule at src/isa/x64/lower.isle line 4293.

15391

                    return Some(v2318);

15392

15393

                let v2319 = &C::vec_mask_from_immediate(ctx, v2249);

15394

                if let Some(v2320) = v2319 {

15395

                    if v525 == true {

15396

                        let v2250 = C::unpack_value_array_2(ctx, v2248);

15397

                        if v2250.0 == v2250.1 {

15398

                            let v2255 = constructor_put_in_xmm(ctx, v2250.0);

15399

                            let v2321 = C::shuffle_0_31_mask(ctx, v2320);

15400

                            let v2322 = &constructor_const_to_xmm_mem(ctx, v2321);

15401

                            let v2323 = constructor_x64_pshufb(ctx, v2255, v2322);

15402

                            let v2324 = constructor_output_xmm(ctx, v2323);

15403

                            // Rule at src/isa/x64/lower.isle line 4306.

15404

                            return Some(v2324);

15405

15406

15407

                    let v332 = C::use_avx512vl(ctx);

15408

                    if v332 == true {

15409

                        let v2329 = C::use_avx512vbmi(ctx);

15410

                        if v2329 == true {

15411

                            let v2325 = C::perm_from_mask_with_zeros(ctx, v2320);

15412

                            if let Some(v2326) = v2325 {

15413

                                let v2330 = constructor_x64_xmm_load_const(ctx, I8X16, v2326.0);

15414

                                let v2250 = C::unpack_value_array_2(ctx, v2248);

15415

                                let v2331 = constructor_put_in_xmm(ctx, v2250.0);

15416

                                let v2332 = &C::put_in_xmm_mem(ctx, v2250.1);

15417

                                let v2333 = constructor_x64_vpermi2b(ctx, v2330, v2331, v2332);

15418

                                let v2334 = &constructor_const_to_xmm_mem(ctx, v2326.1);

15419

                                let v2335 = constructor_x64_andps(ctx, v2333, v2334);

15420

                                let v2336 = constructor_output_xmm(ctx, v2335);

15421

                                // Rule at src/isa/x64/lower.isle line 4313.

15422

                                return Some(v2336);

15423

15424

                            let v2337 = C::perm_from_mask(ctx, v2320);

15425

                            let v2338 = constructor_x64_xmm_load_const(ctx, I8X16, v2337);

15426

                            let v2250 = C::unpack_value_array_2(ctx, v2248);

15427

                            let v2339 = constructor_put_in_xmm(ctx, v2250.0);

15428

                            let v2340 = &C::put_in_xmm_mem(ctx, v2250.1);

15429

                            let v2341 = constructor_x64_vpermi2b(ctx, v2338, v2339, v2340);

15430

                            let v2342 = constructor_output_xmm(ctx, v2341);

15431

                            // Rule at src/isa/x64/lower.isle line 4320.

15432

                            return Some(v2342);

15433

15434

15435

                    let v2250 = C::unpack_value_array_2(ctx, v2248);

15436

                    let v2255 = constructor_put_in_xmm(ctx, v2250.0);

15437

                    let v2343 = C::shuffle_0_15_mask(ctx, v2320);

15438

                    let v2344 = &constructor_const_to_reg_mem(ctx, v2343);

15439

                    let v2345 = constructor_lower_pshufb(ctx, v2255, v2344);

15440

                    let v2346 = constructor_put_in_xmm(ctx, v2250.1);

15441

                    let v2347 = C::shuffle_16_31_mask(ctx, v2320);

15442

                    let v2348 = &constructor_const_to_reg_mem(ctx, v2347);

15443

                    let v2349 = constructor_lower_pshufb(ctx, v2346, v2348);

15444

                    let v2350 = &C::xmm_to_xmm_mem(ctx, v2349);

15445

                    let v2351 = constructor_x64_por(ctx, v2345, v2350);

15446

                    let v2352 = constructor_output_xmm(ctx, v2351);

15447

                    // Rule at src/isa/x64/lower.isle line 4328.

15448

                    return Some(v2352);

15449

15450

15451

15452

        &InstructionData::StackLoad {

15453

            opcode: ref v2159,

15454

            stack_slot: v2160,

15455

            offset: v2161,

15456

        } => {

15457

            if let &Opcode::StackAddr = v2159 {

15458

                let v2162 = constructor_stack_addr_impl(ctx, v2160, v2161);

15459

                let v2163 = constructor_output_gpr(ctx, v2162);

15460

                // Rule at src/isa/x64/lower.isle line 4003.

15461

                return Some(v2163);

15462

15463

15464

        &InstructionData::Store {

15465

            opcode: ref v1551,

15466

            args: ref v1552,

15467

            flags: v1553,

15468

            offset: v1554,

15469

        } => {

15470

            match v1551 {

15471

                &Opcode::Store => {

15472

                    let v1555 = C::unpack_value_array_2(ctx, v1552);

15473

                    let v1573 = C::def_inst(ctx, v1555.0);

15474

                    if let Some(v1574) = v1573 {

15475

                        let v1575 = C::first_result(ctx, v1574);

15476

                        if let Some(v1576) = v1575 {

15477

                            let v1580 = &C::inst_data(ctx, v1574);

15478

                            match v1580 {

15479

                                &InstructionData::Binary {

15480

                                    opcode: ref v1630,

15481

                                    args: ref v1631,

15482

                                } => {

15483

                                    match v1630 {

15484

                                        &Opcode::Iadd => {

15485

                                            let v1577 = C::value_type(ctx, v1576);

15486

                                            let v1628 = C::ty_32_or_64(ctx, v1577);

15487

                                            if let Some(v1629) = v1628 {

15488

                                                let v1632 = C::unpack_value_array_2(ctx, v1631);

15489

                                                let v1635 = &C::sinkable_load(ctx, v1632.0);

15490

                                                if let Some(v1636) = v1635 {

15491

                                                    let v1637 = C::def_inst(ctx, v1632.0);

15492

                                                    if let Some(v1638) = v1637 {

15493

                                                        let v1639 = &C::inst_data(ctx, v1638);

15494

                                                        if let &InstructionData::Load {

15495

                                                            opcode: ref v1640,

15496

                                                            arg: v1641,

15497

                                                            flags: v1642,

15498

                                                            offset: v1643,

15499

                                                        } = v1639

15500

15501

                                                            if let &Opcode::Load = v1640 {

15502

                                                                if v1553 == v1642 {

15503

                                                                    if v1554 == v1643 {

15504

                                                                        if v1555.1 == v1641 {

15505

                                                                            let v1644 = &constructor_sink_load_to_reg_mem_imm(ctx, v1636);

15506

                                                                            let v1645 = &constructor_to_amode(ctx, v1642, v1641, v1643);

15507

                                                                            let v1646 = constructor_put_in_gpr(ctx, v1632.1);

15508

                                                                            let v1647 = &constructor_x64_add_mem(ctx, v1629, v1645, v1646);

15509

                                                                            let v1648 = constructor_side_effect(ctx, v1647);

15510

                                                                            // Rule at src/isa/x64/lower.isle line 3047.

15511

                                                                            return Some(v1648);

15512

15513

15514

15515

15516

15517

15518

15519

                                                let v1649 = &C::sinkable_load(ctx, v1632.1);

15520

                                                if let Some(v1650) = v1649 {

15521

                                                    let v1651 = C::def_inst(ctx, v1632.1);

15522

                                                    if let Some(v1652) = v1651 {

15523

                                                        let v1653 = &C::inst_data(ctx, v1652);

15524

                                                        if let &InstructionData::Load {

15525

                                                            opcode: ref v1654,

15526

                                                            arg: v1655,

15527

                                                            flags: v1656,

15528

                                                            offset: v1657,

15529

                                                        } = v1653

15530

15531

                                                            if let &Opcode::Load = v1654 {

15532

                                                                if v1553 == v1656 {

15533

                                                                    if v1554 == v1657 {

15534

                                                                        if v1555.1 == v1655 {

15535

                                                                            let v1658 = &constructor_sink_load_to_reg_mem_imm(ctx, v1650);

15536

                                                                            let v1659 = &constructor_to_amode(ctx, v1656, v1655, v1657);

15537

                                                                            let v1660 = constructor_put_in_gpr(ctx, v1632.0);

15538

                                                                            let v1661 = &constructor_x64_add_mem(ctx, v1629, v1659, v1660);

15539

                                                                            let v1662 = constructor_side_effect(ctx, v1661);

15540

                                                                            // Rule at src/isa/x64/lower.isle line 3061.

15541

                                                                            return Some(v1662);

15542

15543

15544

15545

15546

15547

15548

15549

15550

15551

                                        &Opcode::Isub => {

15552

                                            let v1577 = C::value_type(ctx, v1576);

15553

                                            let v1628 = C::ty_32_or_64(ctx, v1577);

15554

                                            if let Some(v1629) = v1628 {

15555

                                                let v1632 = C::unpack_value_array_2(ctx, v1631);

15556

                                                let v1635 = &C::sinkable_load(ctx, v1632.0);

15557

                                                if let Some(v1636) = v1635 {

15558

                                                    let v1637 = C::def_inst(ctx, v1632.0);

15559

                                                    if let Some(v1638) = v1637 {

15560

                                                        let v1639 = &C::inst_data(ctx, v1638);

15561

                                                        if let &InstructionData::Load {

15562

                                                            opcode: ref v1640,

15563

                                                            arg: v1641,

15564

                                                            flags: v1642,

15565

                                                            offset: v1643,

15566

                                                        } = v1639

15567

15568

                                                            if let &Opcode::Load = v1640 {

15569

                                                                if v1553 == v1642 {

15570

                                                                    if v1554 == v1643 {

15571

                                                                        if v1555.1 == v1641 {

15572

                                                                            let v1644 = &constructor_sink_load_to_reg_mem_imm(ctx, v1636);

15573

                                                                            let v1645 = &constructor_to_amode(ctx, v1642, v1641, v1643);

15574

                                                                            let v1646 = constructor_put_in_gpr(ctx, v1632.1);

15575

                                                                            let v1663 = &constructor_x64_sub_mem(ctx, v1629, v1645, v1646);

15576

                                                                            let v1664 = constructor_side_effect(ctx, v1663);

15577

                                                                            // Rule at src/isa/x64/lower.isle line 3075.

15578

                                                                            return Some(v1664);

15579

15580

15581

15582

15583

15584

15585

15586

15587

15588

                                        &Opcode::Band => {

15589

                                            let v1577 = C::value_type(ctx, v1576);

15590

                                            let v1628 = C::ty_32_or_64(ctx, v1577);

15591

                                            if let Some(v1629) = v1628 {

15592

                                                let v1632 = C::unpack_value_array_2(ctx, v1631);

15593

                                                let v1635 = &C::sinkable_load(ctx, v1632.0);

15594

                                                if let Some(v1636) = v1635 {

15595

                                                    let v1637 = C::def_inst(ctx, v1632.0);

15596

                                                    if let Some(v1638) = v1637 {

15597

                                                        let v1639 = &C::inst_data(ctx, v1638);

15598

                                                        if let &InstructionData::Load {

15599

                                                            opcode: ref v1640,

15600

                                                            arg: v1641,

15601

                                                            flags: v1642,

15602

                                                            offset: v1643,

15603

                                                        } = v1639

15604

15605

                                                            if let &Opcode::Load = v1640 {

15606

                                                                if v1553 == v1642 {

15607

                                                                    if v1554 == v1643 {

15608

                                                                        if v1555.1 == v1641 {

15609

                                                                            let v1644 = &constructor_sink_load_to_reg_mem_imm(ctx, v1636);

15610

                                                                            let v1645 = &constructor_to_amode(ctx, v1642, v1641, v1643);

15611

                                                                            let v1646 = constructor_put_in_gpr(ctx, v1632.1);

15612

                                                                            let v1665 = &constructor_x64_and_mem(ctx, v1629, v1645, v1646);

15613

                                                                            let v1666 = constructor_side_effect(ctx, v1665);

15614

                                                                            // Rule at src/isa/x64/lower.isle line 3089.

15615

                                                                            return Some(v1666);

15616

15617

15618

15619

15620

15621

15622

15623

                                                let v1649 = &C::sinkable_load(ctx, v1632.1);

15624

                                                if let Some(v1650) = v1649 {

15625

                                                    let v1651 = C::def_inst(ctx, v1632.1);

15626

                                                    if let Some(v1652) = v1651 {

15627

                                                        let v1653 = &C::inst_data(ctx, v1652);

15628

                                                        if let &InstructionData::Load {

15629

                                                            opcode: ref v1654,

15630

                                                            arg: v1655,

15631

                                                            flags: v1656,

15632

                                                            offset: v1657,

15633

                                                        } = v1653

15634

15635

                                                            if let &Opcode::Load = v1654 {

15636

                                                                if v1553 == v1656 {

15637

                                                                    if v1554 == v1657 {

15638

                                                                        if v1555.1 == v1655 {

15639

                                                                            let v1658 = &constructor_sink_load_to_reg_mem_imm(ctx, v1650);

15640

                                                                            let v1659 = &constructor_to_amode(ctx, v1656, v1655, v1657);

15641

                                                                            let v1660 = constructor_put_in_gpr(ctx, v1632.0);

15642

                                                                            let v1667 = &constructor_x64_and_mem(ctx, v1629, v1659, v1660);

15643

                                                                            let v1668 = constructor_side_effect(ctx, v1667);

15644

                                                                            // Rule at src/isa/x64/lower.isle line 3103.

15645

                                                                            return Some(v1668);

15646

15647

15648

15649

15650

15651

15652

15653

15654

15655

                                        &Opcode::Bor => {

15656

                                            let v1577 = C::value_type(ctx, v1576);

15657

                                            let v1628 = C::ty_32_or_64(ctx, v1577);

15658

                                            if let Some(v1629) = v1628 {

15659

                                                let v1632 = C::unpack_value_array_2(ctx, v1631);

15660

                                                let v1635 = &C::sinkable_load(ctx, v1632.0);

15661

                                                if let Some(v1636) = v1635 {

15662

                                                    let v1637 = C::def_inst(ctx, v1632.0);

15663

                                                    if let Some(v1638) = v1637 {

15664

                                                        let v1639 = &C::inst_data(ctx, v1638);

15665

                                                        if let &InstructionData::Load {

15666

                                                            opcode: ref v1640,

15667

                                                            arg: v1641,

15668

                                                            flags: v1642,

15669

                                                            offset: v1643,

15670

                                                        } = v1639

15671

15672

                                                            if let &Opcode::Load = v1640 {

15673

                                                                if v1553 == v1642 {

15674

                                                                    if v1554 == v1643 {

15675

                                                                        if v1555.1 == v1641 {

15676

                                                                            let v1644 = &constructor_sink_load_to_reg_mem_imm(ctx, v1636);

15677

                                                                            let v1645 = &constructor_to_amode(ctx, v1642, v1641, v1643);

15678

                                                                            let v1646 = constructor_put_in_gpr(ctx, v1632.1);

15679

                                                                            let v1669 = &constructor_x64_or_mem(ctx, v1629, v1645, v1646);

15680

                                                                            let v1670 = constructor_side_effect(ctx, v1669);

15681

                                                                            // Rule at src/isa/x64/lower.isle line 3117.

15682

                                                                            return Some(v1670);

15683

15684

15685

15686

15687

15688

15689

15690

                                                let v1649 = &C::sinkable_load(ctx, v1632.1);

15691

                                                if let Some(v1650) = v1649 {

15692

                                                    let v1651 = C::def_inst(ctx, v1632.1);

15693

                                                    if let Some(v1652) = v1651 {

15694

                                                        let v1653 = &C::inst_data(ctx, v1652);

15695

                                                        if let &InstructionData::Load {

15696

                                                            opcode: ref v1654,

15697

                                                            arg: v1655,

15698

                                                            flags: v1656,

15699

                                                            offset: v1657,

15700

                                                        } = v1653

15701

15702

                                                            if let &Opcode::Load = v1654 {

15703

                                                                if v1553 == v1656 {

15704

                                                                    if v1554 == v1657 {

15705

                                                                        if v1555.1 == v1655 {

15706

                                                                            let v1658 = &constructor_sink_load_to_reg_mem_imm(ctx, v1650);

15707

                                                                            let v1659 = &constructor_to_amode(ctx, v1656, v1655, v1657);

15708

                                                                            let v1660 = constructor_put_in_gpr(ctx, v1632.0);

15709

                                                                            let v1671 = &constructor_x64_or_mem(ctx, v1629, v1659, v1660);

15710

                                                                            let v1672 = constructor_side_effect(ctx, v1671);

15711

                                                                            // Rule at src/isa/x64/lower.isle line 3131.

15712

                                                                            return Some(v1672);

15713

15714

15715

15716

15717

15718

15719

15720

15721

15722

                                        &Opcode::Bxor => {

15723

                                            let v1577 = C::value_type(ctx, v1576);

15724

                                            let v1628 = C::ty_32_or_64(ctx, v1577);

15725

                                            if let Some(v1629) = v1628 {

15726

                                                let v1632 = C::unpack_value_array_2(ctx, v1631);

15727

                                                let v1635 = &C::sinkable_load(ctx, v1632.0);

15728

                                                if let Some(v1636) = v1635 {

15729

                                                    let v1637 = C::def_inst(ctx, v1632.0);

15730

                                                    if let Some(v1638) = v1637 {

15731

                                                        let v1639 = &C::inst_data(ctx, v1638);

15732

                                                        if let &InstructionData::Load {

15733

                                                            opcode: ref v1640,

15734

                                                            arg: v1641,

15735

                                                            flags: v1642,

15736

                                                            offset: v1643,

15737

                                                        } = v1639

15738

15739

                                                            if let &Opcode::Load = v1640 {

15740

                                                                if v1553 == v1642 {

15741

                                                                    if v1554 == v1643 {

15742

                                                                        if v1555.1 == v1641 {

15743

                                                                            let v1644 = &constructor_sink_load_to_reg_mem_imm(ctx, v1636);

15744

                                                                            let v1645 = &constructor_to_amode(ctx, v1642, v1641, v1643);

15745

                                                                            let v1646 = constructor_put_in_gpr(ctx, v1632.1);

15746

                                                                            let v1673 = &constructor_x64_xor_mem(ctx, v1629, v1645, v1646);

15747

                                                                            let v1674 = constructor_side_effect(ctx, v1673);

15748

                                                                            // Rule at src/isa/x64/lower.isle line 3145.

15749

                                                                            return Some(v1674);

15750

15751

15752

15753

15754

15755

15756

15757

                                                let v1649 = &C::sinkable_load(ctx, v1632.1);

15758

                                                if let Some(v1650) = v1649 {

15759

                                                    let v1651 = C::def_inst(ctx, v1632.1);

15760

                                                    if let Some(v1652) = v1651 {

15761

                                                        let v1653 = &C::inst_data(ctx, v1652);

15762

                                                        if let &InstructionData::Load {

15763

                                                            opcode: ref v1654,

15764

                                                            arg: v1655,

15765

                                                            flags: v1656,

15766

                                                            offset: v1657,

15767

                                                        } = v1653

15768

15769

                                                            if let &Opcode::Load = v1654 {

15770

                                                                if v1553 == v1656 {

15771

                                                                    if v1554 == v1657 {

15772

                                                                        if v1555.1 == v1655 {

15773

                                                                            let v1658 = &constructor_sink_load_to_reg_mem_imm(ctx, v1650);

15774

                                                                            let v1659 = &constructor_to_amode(ctx, v1656, v1655, v1657);

15775

                                                                            let v1660 = constructor_put_in_gpr(ctx, v1632.0);

15776

                                                                            let v1675 = &constructor_x64_xor_mem(ctx, v1629, v1659, v1660);

15777

                                                                            let v1676 = constructor_side_effect(ctx, v1675);

15778

                                                                            // Rule at src/isa/x64/lower.isle line 3159.

15779

                                                                            return Some(v1676);

15780

15781

15782

15783

15784

15785

15786

15787

15788

15789

                                        _ => {}

15790

15791

15792

                                &InstructionData::BinaryImm8 {

15793

                                    opcode: ref v1611,

15794

                                    arg: v1612,

15795

                                    imm: v1613,

15796

                                } => {

15797

                                    if let &Opcode::Extractlane = v1611 {

15798

                                        let v1577 = C::value_type(ctx, v1576);

15799

                                        match v1577 {

15800

                                            I8 => {

15801

                                                let v441 = C::use_sse41(ctx);

15802

                                                if v441 == true {

15803

                                                    let v1562 = &constructor_to_amode(

15804

                                                        ctx, v1553, v1555.1, v1554,

15805

);

15806

                                                    let v1563 =

15807

                                                        &C::amode_to_synthetic_amode(ctx, v1562);

15808

                                                    let v1615 = constructor_put_in_xmm(ctx, v1612);

15809

                                                    let v1614 = C::u8_from_uimm8(ctx, v1613);

15810

                                                    let v1620 = &constructor_x64_pextrb_store(

15811

                                                        ctx, v1563, v1615, v1614,

15812

);

15813

                                                    let v1621 = constructor_side_effect(ctx, v1620);

15814

                                                    // Rule at src/isa/x64/lower.isle line 3015.

15815

                                                    return Some(v1621);

15816

15817

15818

                                            I16 => {

15819

                                                let v441 = C::use_sse41(ctx);

15820

                                                if v441 == true {

15821

                                                    let v1562 = &constructor_to_amode(

15822

                                                        ctx, v1553, v1555.1, v1554,

15823

);

15824

                                                    let v1563 =

15825

                                                        &C::amode_to_synthetic_amode(ctx, v1562);

15826

                                                    let v1615 = constructor_put_in_xmm(ctx, v1612);

15827

                                                    let v1614 = C::u8_from_uimm8(ctx, v1613);

15828

                                                    let v1622 = &constructor_x64_pextrw_store(

15829

                                                        ctx, v1563, v1615, v1614,

15830

);

15831

                                                    let v1623 = constructor_side_effect(ctx, v1622);

15832

                                                    // Rule at src/isa/x64/lower.isle line 3022.

15833

                                                    return Some(v1623);

15834

15835

15836

                                            I32 => {

15837

                                                let v441 = C::use_sse41(ctx);

15838

                                                if v441 == true {

15839

                                                    let v1562 = &constructor_to_amode(

15840

                                                        ctx, v1553, v1555.1, v1554,

15841

);

15842

                                                    let v1563 =

15843

                                                        &C::amode_to_synthetic_amode(ctx, v1562);

15844

                                                    let v1615 = constructor_put_in_xmm(ctx, v1612);

15845

                                                    let v1614 = C::u8_from_uimm8(ctx, v1613);

15846

                                                    let v1624 = &constructor_x64_pextrd_store(

15847

                                                        ctx, v1563, v1615, v1614,

15848

);

15849

                                                    let v1625 = constructor_side_effect(ctx, v1624);

15850

                                                    // Rule at src/isa/x64/lower.isle line 3029.

15851

                                                    return Some(v1625);

15852

15853

15854

                                            I64 => {

15855

                                                let v441 = C::use_sse41(ctx);

15856

                                                if v441 == true {

15857

                                                    let v1562 = &constructor_to_amode(

15858

                                                        ctx, v1553, v1555.1, v1554,

15859

);

15860

                                                    let v1563 =

15861

                                                        &C::amode_to_synthetic_amode(ctx, v1562);

15862

                                                    let v1615 = constructor_put_in_xmm(ctx, v1612);

15863

                                                    let v1614 = C::u8_from_uimm8(ctx, v1613);

15864

                                                    let v1626 = &constructor_x64_pextrq_store(

15865

                                                        ctx, v1563, v1615, v1614,

15866

);

15867

                                                    let v1627 = constructor_side_effect(ctx, v1626);

15868

                                                    // Rule at src/isa/x64/lower.isle line 3036.

15869

                                                    return Some(v1627);

15870

15871

15872

                                            F32 => {

15873

                                                let v1614 = C::u8_from_uimm8(ctx, v1613);

15874

                                                if v1614 == 0x0 {

15875

                                                    let v1562 = &constructor_to_amode(

15876

                                                        ctx, v1553, v1555.1, v1554,

15877

);

15878

                                                    let v1563 =

15879

                                                        &C::amode_to_synthetic_amode(ctx, v1562);

15880

                                                    let v1615 = constructor_put_in_xmm(ctx, v1612);

15881

                                                    let v1616 = &constructor_x64_movss_store(

15882

                                                        ctx, v1563, v1615,

15883

);

15884

                                                    let v1617 = constructor_side_effect(ctx, v1616);

15885

                                                    // Rule at src/isa/x64/lower.isle line 3003.

15886

                                                    return Some(v1617);

15887

15888

15889

                                            F64 => {

15890

                                                let v1614 = C::u8_from_uimm8(ctx, v1613);

15891

                                                if v1614 == 0x0 {

15892

                                                    let v1562 = &constructor_to_amode(

15893

                                                        ctx, v1553, v1555.1, v1554,

15894

);

15895

                                                    let v1563 =

15896

                                                        &C::amode_to_synthetic_amode(ctx, v1562);

15897

                                                    let v1615 = constructor_put_in_xmm(ctx, v1612);

15898

                                                    let v1618 = &constructor_x64_movsd_store(

15899

                                                        ctx, v1563, v1615,

15900

);

15901

                                                    let v1619 = constructor_side_effect(ctx, v1618);

15902

                                                    // Rule at src/isa/x64/lower.isle line 3009.

15903

                                                    return Some(v1619);

15904

15905

15906

                                            _ => {}

15907

15908

15909

15910

                                &InstructionData::UnaryImm {

15911

                                    opcode: ref v1581,

15912

                                    imm: v1582,

15913

                                } => {

15914

                                    if let &Opcode::Iconst = v1581 {

15915

                                        let v1577 = C::value_type(ctx, v1576);

15916

                                        let v1578 = C::fits_in_64(ctx, v1577);

15917

                                        if let Some(v1579) = v1578 {

15918

                                            let v1583 = C::simm32(ctx, v1582);

15919

                                            if let Some(v1584) = v1583 {

15920

                                                let v1562 = &constructor_to_amode(

15921

                                                    ctx, v1553, v1555.1, v1554,

15922

);

15923

                                                let v1563 =

15924

                                                    &C::amode_to_synthetic_amode(ctx, v1562);

15925

                                                let v1585 = &constructor_x64_movimm_m(

15926

                                                    ctx, v1579, v1563, v1584,

15927

);

15928

                                                let v1586 = constructor_side_effect(ctx, v1585);

15929

                                                // Rule at src/isa/x64/lower.isle line 2939.

15930

                                                return Some(v1586);

15931

15932

15933

15934

15935

                                _ => {}

15936

15937

15938

15939

                    let v1558 = C::value_type(ctx, v1555.0);

15940

                    match v1558 {

15941

                        I128 => {

15942

                            let v1600 = C::put_in_regs(ctx, v1555.0);

15943

                            let v1601 = constructor_value_regs_get_gpr(ctx, v1600, 0x0);

15944

                            let v1602 = constructor_value_regs_get_gpr(ctx, v1600, 0x1);

15945

                            let v1603 = &constructor_to_amode(ctx, v1553, v1555.1, v1554);

15946

                            let v1604 = &C::amode_offset(ctx, v1603, 0x8);

15947

                            let v1605 = &C::amode_to_synthetic_amode(ctx, v1603);

15948

                            let v1606 = &constructor_x64_movrm(ctx, I64, v1605, v1601);

15949

                            let v1607 = &C::amode_to_synthetic_amode(ctx, v1604);

15950

                            let v1608 = &constructor_x64_movrm(ctx, I64, v1607, v1602);

15951

                            let v1609 = &constructor_side_effect_concat(ctx, v1606, v1608);

15952

                            let v1610 = constructor_side_effect(ctx, v1609);

15953

                            // Rule at src/isa/x64/lower.isle line 2984.

15954

                            return Some(v1610);

15955

15956

                        F32 => {

15957

                            let v1562 = &constructor_to_amode(ctx, v1553, v1555.1, v1554);

15958

                            let v1563 = &C::amode_to_synthetic_amode(ctx, v1562);

15959

                            let v1587 = constructor_put_in_xmm(ctx, v1555.0);

15960

                            let v1588 = &constructor_x64_movss_store(ctx, v1563, v1587);

15961

                            let v1589 = constructor_side_effect(ctx, v1588);

15962

                            // Rule at src/isa/x64/lower.isle line 2944.

15963

                            return Some(v1589);

15964

15965

                        F64 => {

15966

                            let v1562 = &constructor_to_amode(ctx, v1553, v1555.1, v1554);

15967

                            let v1563 = &C::amode_to_synthetic_amode(ctx, v1562);

15968

                            let v1587 = constructor_put_in_xmm(ctx, v1555.0);

15969

                            let v1590 = &constructor_x64_movsd_store(ctx, v1563, v1587);

15970

                            let v1591 = constructor_side_effect(ctx, v1590);

15971

                            // Rule at src/isa/x64/lower.isle line 2952.

15972

                            return Some(v1591);

15973

15974

                        F32X4 => {

15975

                            let v1562 = &constructor_to_amode(ctx, v1553, v1555.1, v1554);

15976

                            let v1563 = &C::amode_to_synthetic_amode(ctx, v1562);

15977

                            let v1587 = constructor_put_in_xmm(ctx, v1555.0);

15978

                            let v1592 = &constructor_x64_movups_store(ctx, v1563, v1587);

15979

                            let v1593 = constructor_side_effect(ctx, v1592);

15980

                            // Rule at src/isa/x64/lower.isle line 2960.

15981

                            return Some(v1593);

15982

15983

                        F64X2 => {

15984

                            let v1562 = &constructor_to_amode(ctx, v1553, v1555.1, v1554);

15985

                            let v1563 = &C::amode_to_synthetic_amode(ctx, v1562);

15986

                            let v1587 = constructor_put_in_xmm(ctx, v1555.0);

15987

                            let v1594 = &constructor_x64_movupd_store(ctx, v1563, v1587);

15988

                            let v1595 = constructor_side_effect(ctx, v1594);

15989

                            // Rule at src/isa/x64/lower.isle line 2968.

15990

                            return Some(v1595);

15991

15992

                        _ => {}

15993

15994

                    let v1596 = C::ty_vec128_int(ctx, v1558);

15995

                    if let Some(v1597) = v1596 {

15996

                        let v1562 = &constructor_to_amode(ctx, v1553, v1555.1, v1554);

15997

                        let v1563 = &C::amode_to_synthetic_amode(ctx, v1562);

15998

                        let v1587 = constructor_put_in_xmm(ctx, v1555.0);

15999

                        let v1598 = &constructor_x64_movdqu_store(ctx, v1563, v1587);

16000

                        let v1599 = constructor_side_effect(ctx, v1598);

16001

                        // Rule at src/isa/x64/lower.isle line 2976.

16002

                        return Some(v1599);

16003

16004

                    let v1559 = &C::type_register_class(ctx, v1558);

16005

                    if let Some(v1560) = v1559 {

16006

                        if let &RegisterClass::Gpr {

16007

                            single_register: v1561,

16008

                        } = v1560

16009

16010

                            let v1562 = &constructor_to_amode(ctx, v1553, v1555.1, v1554);

16011

                            let v1563 = &C::amode_to_synthetic_amode(ctx, v1562);

16012

                            let v1564 = constructor_put_in_gpr(ctx, v1555.0);

16013

                            let v1565 = &constructor_x64_movrm(ctx, v1558, v1563, v1564);

16014

                            let v1566 = constructor_side_effect(ctx, v1565);

16015

                            // Rule at src/isa/x64/lower.isle line 2920.

16016

                            return Some(v1566);

16017

16018

16019

16020

                &Opcode::Istore8 => {

16021

                    let v1555 = C::unpack_value_array_2(ctx, v1552);

16022

                    let v1562 = &constructor_to_amode(ctx, v1553, v1555.1, v1554);

16023

                    let v1563 = &C::amode_to_synthetic_amode(ctx, v1562);

16024

                    let v1564 = constructor_put_in_gpr(ctx, v1555.0);

16025

                    let v1567 = &constructor_x64_movrm(ctx, I8, v1563, v1564);

16026

                    let v1568 = constructor_side_effect(ctx, v1567);

16027

                    // Rule at src/isa/x64/lower.isle line 2928.

16028

                    return Some(v1568);

16029

16030

                &Opcode::Istore16 => {

16031

                    let v1555 = C::unpack_value_array_2(ctx, v1552);

16032

                    let v1562 = &constructor_to_amode(ctx, v1553, v1555.1, v1554);

16033

                    let v1563 = &C::amode_to_synthetic_amode(ctx, v1562);

16034

                    let v1564 = constructor_put_in_gpr(ctx, v1555.0);

16035

                    let v1569 = &constructor_x64_movrm(ctx, I16, v1563, v1564);

16036

                    let v1570 = constructor_side_effect(ctx, v1569);

16037

                    // Rule at src/isa/x64/lower.isle line 2931.

16038

                    return Some(v1570);

16039

16040

                &Opcode::Istore32 => {

16041

                    let v1555 = C::unpack_value_array_2(ctx, v1552);

16042

                    let v1562 = &constructor_to_amode(ctx, v1553, v1555.1, v1554);

16043

                    let v1563 = &C::amode_to_synthetic_amode(ctx, v1562);

16044

                    let v1564 = constructor_put_in_gpr(ctx, v1555.0);

16045

                    let v1571 = &constructor_x64_movrm(ctx, I32, v1563, v1564);

16046

                    let v1572 = constructor_side_effect(ctx, v1571);

16047

                    // Rule at src/isa/x64/lower.isle line 2934.

16048

                    return Some(v1572);

16049

16050

                _ => {}

16051

16052

16053

        &InstructionData::StoreNoOffset {

16054

            opcode: ref v1710,

16055

            args: ref v1711,

16056

            flags: v1712,

16057

        } => {

16058

            if let &Opcode::AtomicStore = v1710 {

16059

                let v1713 = C::unpack_value_array_2(ctx, v1711);

16060

                let v1716 = C::value_type(ctx, v1713.0);

16061

                let v1717 = C::fits_in_64(ctx, v1716);

16062

                if let Some(v1718) = v1717 {

16063

                    let v1719 = C::ty_int(ctx, v1716);

16064

                    if let Some(v1720) = v1719 {

16065

                        let v48 = C::zero_offset(ctx);

16066

                        let v1721 = &constructor_to_amode(ctx, v1712, v1713.1, v48);

16067

                        let v1722 = &C::amode_to_synthetic_amode(ctx, v1721);

16068

                        let v1723 = constructor_put_in_gpr(ctx, v1713.0);

16069

                        let v1724 = &constructor_x64_movrm(ctx, v1718, v1722, v1723);

16070

                        let v1725 = &constructor_x64_mfence(ctx);

16071

                        let v1726 = &constructor_side_effect_concat(ctx, v1724, v1725);

16072

                        let v1727 = constructor_side_effect(ctx, v1726);

16073

                        // Rule at src/isa/x64/lower.isle line 3206.

16074

                        return Some(v1727);

16075

16076

16077

16078

16079

        &InstructionData::Ternary {

16080

            opcode: ref v634,

16081

            args: ref v635,

16082

        } => {

16083

            match v634 {

16084

                &Opcode::Select => {

16085

                    let v1 = C::first_result(ctx, arg0);

16086

                    if let Some(v2) = v1 {

16087

                        let v636 = C::unpack_value_array_3(ctx, v635);

16088

                        let v1007 = C::maybe_uextend(ctx, v636.0);

16089

                        if let Some(v1008) = v1007 {

16090

                            let v1009 = C::def_inst(ctx, v1008);

16091

                            if let Some(v1010) = v1009 {

16092

                                let v1011 = &C::inst_data(ctx, v1010);

16093

                                match v1011 {

16094

                                    &InstructionData::FloatCompare {

16095

                                        opcode: ref v1012,

16096

                                        args: ref v1013,

16097

                                        cond: ref v1014,

16098

                                    } => {

16099

                                        if let &Opcode::Fcmp = v1012 {

16100

                                            match v1014 {

16101

                                                &FloatCC::Equal => {

16102

                                                    let v1015 = C::unpack_value_array_2(ctx, v1013);

16103

                                                    let v1021 = &constructor_emit_fcmp(

16104

                                                        ctx,

16105

                                                        &FloatCC::NotEqual,

16106

                                                        v1015.0,

16107

                                                        v1015.1,

16108

);

16109

                                                    let v3 = C::value_type(ctx, v2);

16110

                                                    let v1022 = constructor_lower_select_fcmp(

16111

                                                        ctx, v3, v1021, v636.2, v636.1,

16112

);

16113

                                                    // Rule at src/isa/x64/lower.isle line 2049.

16114

                                                    return Some(v1022);

16115

16116

                                                &FloatCC::LessThan => {

16117

                                                    let v3 = C::value_type(ctx, v2);

16118

                                                    match v3 {

16119

                                                        F32 => {

16120

                                                            let v1015 =

16121

                                                                C::unpack_value_array_2(ctx, v1013);

16122

                                                            if v636.1 == v1015.1 {

16123

                                                                if v636.2 == v1015.0 {

16124

                                                                    let v1061 =

16125

                                                                        constructor_put_in_xmm(

16126

                                                                            ctx, v1015.1,

16127

);

16128

                                                                    let v1062 = &C::put_in_xmm_mem(

16129

                                                                        ctx, v1015.0,

16130

);

16131

                                                                    let v1063 =

16132

                                                                        constructor_x64_maxss(

16133

                                                                            ctx, v1061, v1062,

16134

);

16135

                                                                    let v1064 =

16136

                                                                        constructor_output_xmm(

16137

                                                                            ctx, v1063,

16138

);

16139

                                                                    // Rule at src/isa/x64/lower.isle line 2088.

16140

                                                                    return Some(v1064);

16141

16142

16143

                                                            if v636.1 == v1015.0 {

16144

                                                                if v636.2 == v1015.1 {

16145

                                                                    let v1055 =

16146

                                                                        constructor_put_in_xmm(

16147

                                                                            ctx, v1015.0,

16148

);

16149

                                                                    let v1056 = &C::put_in_xmm_mem(

16150

                                                                        ctx, v1015.1,

16151

);

16152

                                                                    let v1057 =

16153

                                                                        constructor_x64_minss(

16154

                                                                            ctx, v1055, v1056,

16155

);

16156

                                                                    let v1058 =

16157

                                                                        constructor_output_xmm(

16158

                                                                            ctx, v1057,

16159

);

16160

                                                                    // Rule at src/isa/x64/lower.isle line 2084.

16161

                                                                    return Some(v1058);

16162

16163

16164

16165

                                                        F64 => {

16166

                                                            let v1015 =

16167

                                                                C::unpack_value_array_2(ctx, v1013);

16168

                                                            if v636.1 == v1015.1 {

16169

                                                                if v636.2 == v1015.0 {

16170

                                                                    let v1061 =

16171

                                                                        constructor_put_in_xmm(

16172

                                                                            ctx, v1015.1,

16173

);

16174

                                                                    let v1062 = &C::put_in_xmm_mem(

16175

                                                                        ctx, v1015.0,

16176

);

16177

                                                                    let v1065 =

16178

                                                                        constructor_x64_maxsd(

16179

                                                                            ctx, v1061, v1062,

16180

);

16181

                                                                    let v1066 =

16182

                                                                        constructor_output_xmm(

16183

                                                                            ctx, v1065,

16184

);

16185

                                                                    // Rule at src/isa/x64/lower.isle line 2090.

16186

                                                                    return Some(v1066);

16187

16188

16189

                                                            if v636.1 == v1015.0 {

16190

                                                                if v636.2 == v1015.1 {

16191

                                                                    let v1055 =

16192

                                                                        constructor_put_in_xmm(

16193

                                                                            ctx, v1015.0,

16194

);

16195

                                                                    let v1056 = &C::put_in_xmm_mem(

16196

                                                                        ctx, v1015.1,

16197

);

16198

                                                                    let v1059 =

16199

                                                                        constructor_x64_minsd(

16200

                                                                            ctx, v1055, v1056,

16201

);

16202

                                                                    let v1060 =

16203

                                                                        constructor_output_xmm(

16204

                                                                            ctx, v1059,

16205

);

16206

                                                                    // Rule at src/isa/x64/lower.isle line 2086.

16207

                                                                    return Some(v1060);

16208

16209

16210

16211

                                                        _ => {}

16212

16213

16214

                                                _ => {}

16215

16216

                                            let v1015 = C::unpack_value_array_2(ctx, v1013);

16217

                                            let v1018 = &constructor_emit_fcmp(

16218

                                                ctx, v1014, v1015.0, v1015.1,

16219

);

16220

                                            let v3 = C::value_type(ctx, v2);

16221

                                            let v1019 = constructor_lower_select_fcmp(

16222

                                                ctx, v3, v1018, v636.1, v636.2,

16223

);

16224

                                            // Rule at src/isa/x64/lower.isle line 2047.

16225

                                            return Some(v1019);

16226

16227

16228

                                    &InstructionData::IntCompare {

16229

                                        opcode: ref v1023,

16230

                                        args: ref v1024,

16231

                                        cond: ref v1025,

16232

                                    } => {

16233

                                        if let &Opcode::Icmp = v1023 {

16234

                                            let v1026 = C::unpack_value_array_2(ctx, v1024);

16235

                                            let v1029 = C::value_type(ctx, v1026.0);

16236

                                            let v1030 = C::fits_in_64(ctx, v1029);

16237

                                            if let Some(v1031) = v1030 {

16238

                                                let v1032 =

16239

                                                    &C::raw_operand_size_of_type(ctx, v1031);

16240

                                                let v1033 =

16241

                                                    &constructor_put_in_gpr_mem_imm(ctx, v1026.1);

16242

                                                let v1034 = constructor_put_in_gpr(ctx, v1026.0);

16243

                                                let v1035 =

16244

                                                    &constructor_x64_cmp(ctx, v1032, v1033, v1034);

16245

                                                let v1036 = &C::intcc_to_cc(ctx, v1025);

16246

                                                let v3 = C::value_type(ctx, v2);

16247

                                                let v1037 = &constructor_cmove_from_values(

16248

                                                    ctx, v3, v1036, v636.1, v636.2,

16249

);

16250

                                                let v1038 =

16251

                                                    constructor_with_flags(ctx, v1035, v1037);

16252

                                                let v1039 = C::output(ctx, v1038);

16253

                                                // Rule at src/isa/x64/lower.isle line 2063.

16254

                                                return Some(v1039);

16255

16256

16257

16258

                                    _ => {}

16259

16260

16261

16262

                        let v1040 = C::value_type(ctx, v636.0);

16263

                        let v1041 = C::fits_in_64(ctx, v1040);

16264

                        if let Some(v1042) = v1041 {

16265

                            let v1043 = &C::raw_operand_size_of_type(ctx, v1042);

16266

                            let v1044 = constructor_put_in_gpr(ctx, v636.0);

16267

                            let v1045 = &C::gpr_to_gpr_mem_imm(ctx, v1044);

16268

                            let v1046 = &constructor_x64_test(ctx, v1043, v1045, v1044);

16269

                            let v3 = C::value_type(ctx, v2);

16270

                            let v1048 =

16271

                                &constructor_cmove_from_values(ctx, v3, &CC::NZ, v636.1, v636.2);

16272

                            let v1049 = constructor_with_flags(ctx, v1046, v1048);

16273

                            let v1050 = C::output(ctx, v1049);

16274

                            // Rule at src/isa/x64/lower.isle line 2070.

16275

                            return Some(v1050);

16276

16277

                        if v1040 == I128 {

16278

                            let v683 = C::put_in_regs(ctx, v636.0);

16279

                            let v1052 = &constructor_cmp_zero_i128(ctx, &CC::Z, v683);

16280

                            let v1053 = constructor_select_icmp(ctx, v1052, v636.1, v636.2);

16281

                            let v1054 = C::output(ctx, v1053);

16282

                            // Rule at src/isa/x64/lower.isle line 2077.

16283

                            return Some(v1054);

16284

16285

16286

16287

                &Opcode::SelectSpectreGuard => {

16288

                    let v636 = C::unpack_value_array_3(ctx, v635);

16289

                    let v656 = C::def_inst(ctx, v636.0);

16290

                    if let Some(v657) = v656 {

16291

                        let v658 = &C::inst_data(ctx, v657);

16292

                        if let &InstructionData::IntCompare {

16293

                            opcode: ref v1783,

16294

                            args: ref v1784,

16295

                            cond: ref v1785,

16296

                        } = v658

16297

16298

                            if let &Opcode::Icmp = v1783 {

16299

                                let v1786 = C::unpack_value_array_2(ctx, v1784);

16300

                                let v1789 = &constructor_emit_cmp(ctx, v1785, v1786.0, v1786.1);

16301

                                let v1790 = constructor_select_icmp(ctx, v1789, v636.1, v636.2);

16302

                                let v1791 = C::output(ctx, v1790);

16303

                                // Rule at src/isa/x64/lower.isle line 3325.

16304

                                return Some(v1791);

16305

16306

16307

16308

                    let v1 = C::first_result(ctx, arg0);

16309

                    if let Some(v2) = v1 {

16310

                        let v1040 = C::value_type(ctx, v636.0);

16311

                        let v1041 = C::fits_in_64(ctx, v1040);

16312

                        if let Some(v1042) = v1041 {

16313

                            let v1043 = &C::raw_operand_size_of_type(ctx, v1042);

16314

                            let v1044 = constructor_put_in_gpr(ctx, v636.0);

16315

                            let v1045 = &C::gpr_to_gpr_mem_imm(ctx, v1044);

16316

                            let v1046 = &constructor_x64_test(ctx, v1043, v1045, v1044);

16317

                            let v3 = C::value_type(ctx, v2);

16318

                            let v1048 =

16319

                                &constructor_cmove_from_values(ctx, v3, &CC::NZ, v636.1, v636.2);

16320

                            let v1049 = constructor_with_flags(ctx, v1046, v1048);

16321

                            let v1050 = C::output(ctx, v1049);

16322

                            // Rule at src/isa/x64/lower.isle line 3328.

16323

                            return Some(v1050);

16324

16325

                        if v1040 == I128 {

16326

                            let v683 = C::put_in_regs(ctx, v636.0);

16327

                            let v1052 = &constructor_cmp_zero_i128(ctx, &CC::Z, v683);

16328

                            let v1053 = constructor_select_icmp(ctx, v1052, v636.1, v636.2);

16329

                            let v1054 = C::output(ctx, v1053);

16330

                            // Rule at src/isa/x64/lower.isle line 3333.

16331

                            return Some(v1054);

16332

16333

16334

16335

                &Opcode::Bitselect => {

16336

                    let v1 = C::first_result(ctx, arg0);

16337

                    if let Some(v2) = v1 {

16338

                        let v3 = C::value_type(ctx, v2);

16339

                        let v162 = C::ty_scalar_float(ctx, v3);

16340

                        if let Some(v163) = v162 {

16341

                            let v636 = C::unpack_value_array_3(ctx, v635);

16342

                            let v640 = constructor_put_in_xmm(ctx, v636.0);

16343

                            let v652 = &C::put_in_xmm_mem(ctx, v636.1);

16344

                            let v703 = constructor_sse_and(ctx, v163, v640, v652);

16345

                            let v704 = constructor_put_in_xmm(ctx, v636.0);

16346

                            let v705 = constructor_vector_all_ones(ctx);

16347

                            let v706 = &C::xmm_to_xmm_mem(ctx, v705);

16348

                            let v707 = constructor_x64_xor_vector(ctx, v163, v704, v706);

16349

                            let v708 = &C::put_in_xmm_mem(ctx, v636.2);

16350

                            let v709 = constructor_sse_and(ctx, v163, v707, v708);

16351

                            let v710 = &C::xmm_to_xmm_mem(ctx, v709);

16352

                            let v711 = constructor_sse_or(ctx, v163, v703, v710);

16353

                            let v712 = constructor_output_xmm(ctx, v711);

16354

                            // Rule at src/isa/x64/lower.isle line 1437.

16355

                            return Some(v712);

16356

16357

                        let v691 = C::ty_int_ref_scalar_64_extract(ctx, v3);

16358

                        if let Some(v692) = v691 {

16359

                            let v636 = C::unpack_value_array_3(ctx, v635);

16360

                            let v693 = constructor_put_in_gpr(ctx, v636.0);

16361

                            let v694 = &constructor_put_in_gpr_mem_imm(ctx, v636.1);

16362

                            let v695 = constructor_x64_and(ctx, v692, v693, v694);

16363

                            let v696 = constructor_put_in_gpr(ctx, v636.0);

16364

                            let v697 = constructor_x64_not(ctx, v692, v696);

16365

                            let v698 = &constructor_put_in_gpr_mem_imm(ctx, v636.2);

16366

                            let v699 = constructor_x64_and(ctx, v692, v697, v698);

16367

                            let v700 = &C::gpr_to_gpr_mem_imm(ctx, v699);

16368

                            let v701 = constructor_x64_or(ctx, v692, v695, v700);

16369

                            let v702 = constructor_output_gpr(ctx, v701);

16370

                            // Rule at src/isa/x64/lower.isle line 1432.

16371

                            return Some(v702);

16372

16373

                        match v3 {

16374

                            I128 => {

16375

                                let v636 = C::unpack_value_array_3(ctx, v635);

16376

                                let v683 = C::put_in_regs(ctx, v636.0);

16377

                                let v684 = C::put_in_regs(ctx, v636.1);

16378

                                let v685 = constructor_and_i128(ctx, v683, v684);

16379

                                let v686 = constructor_i128_not(ctx, v636.0);

16380

                                let v687 = C::put_in_regs(ctx, v636.2);

16381

                                let v688 = constructor_and_i128(ctx, v686, v687);

16382

                                let v689 = constructor_or_i128(ctx, v685, v688);

16383

                                let v690 = C::output(ctx, v689);

16384

                                // Rule at src/isa/x64/lower.isle line 1427.

16385

                                return Some(v690);

16386

16387

                            F32X4 => {

16388

                                let v636 = C::unpack_value_array_3(ctx, v635);

16389

                                let v656 = C::def_inst(ctx, v636.0);

16390

                                if let Some(v657) = v656 {

16391

                                    let v658 = &C::inst_data(ctx, v657);

16392

                                    if let &InstructionData::LoadNoOffset {

16393

                                        opcode: ref v659,

16394

                                        arg: v660,

16395

                                        flags: v661,

16396

                                    } = v658

16397

16398

                                        if let &Opcode::Bitcast = v659 {

16399

                                            let v662 = C::def_inst(ctx, v660);

16400

                                            if let Some(v663) = v662 {

16401

                                                let v664 = &C::inst_data(ctx, v663);

16402

                                                if let &InstructionData::FloatCompare {

16403

                                                    opcode: ref v665,

16404

                                                    args: ref v666,

16405

                                                    cond: ref v667,

16406

                                                } = v664

16407

16408

                                                    if let &Opcode::Fcmp = v665 {

16409

                                                        if let &FloatCC::LessThan = v667 {

16410

                                                            let v668 =

16411

                                                                C::unpack_value_array_2(ctx, v666);

16412

                                                            if v636.1 == v668.1 {

16413

                                                                if v636.2 == v668.0 {

16414

                                                                    let v677 =

16415

                                                                        constructor_put_in_xmm(

16416

                                                                            ctx, v668.1,

16417

);

16418

                                                                    let v678 = &C::put_in_xmm_mem(

16419

                                                                        ctx, v668.0,

16420

);

16421

                                                                    let v679 =

16422

                                                                        constructor_x64_maxps(

16423

                                                                            ctx, v677, v678,

16424

);

16425

                                                                    let v680 =

16426

                                                                        constructor_output_xmm(

16427

                                                                            ctx, v679,

16428

);

16429

                                                                    // Rule at src/isa/x64/lower.isle line 1420.

16430

                                                                    return Some(v680);

16431

16432

16433

                                                            if v636.1 == v668.0 {

16434

                                                                if v636.2 == v668.1 {

16435

                                                                    let v671 =

16436

                                                                        constructor_put_in_xmm(

16437

                                                                            ctx, v668.0,

16438

);

16439

                                                                    let v672 = &C::put_in_xmm_mem(

16440

                                                                        ctx, v668.1,

16441

);

16442

                                                                    let v673 =

16443

                                                                        constructor_x64_minps(

16444

                                                                            ctx, v671, v672,

16445

);

16446

                                                                    let v674 =

16447

                                                                        constructor_output_xmm(

16448

                                                                            ctx, v673,

16449

);

16450

                                                                    // Rule at src/isa/x64/lower.isle line 1415.

16451

                                                                    return Some(v674);

16452

16453

16454

16455

16456

16457

16458

16459

16460

16461

16462

                            F64X2 => {

16463

                                let v636 = C::unpack_value_array_3(ctx, v635);

16464

                                let v656 = C::def_inst(ctx, v636.0);

16465

                                if let Some(v657) = v656 {

16466

                                    let v658 = &C::inst_data(ctx, v657);

16467

                                    if let &InstructionData::LoadNoOffset {

16468

                                        opcode: ref v659,

16469

                                        arg: v660,

16470

                                        flags: v661,

16471

                                    } = v658

16472

16473

                                        if let &Opcode::Bitcast = v659 {

16474

                                            let v662 = C::def_inst(ctx, v660);

16475

                                            if let Some(v663) = v662 {

16476

                                                let v664 = &C::inst_data(ctx, v663);

16477

                                                if let &InstructionData::FloatCompare {

16478

                                                    opcode: ref v665,

16479

                                                    args: ref v666,

16480

                                                    cond: ref v667,

16481

                                                } = v664

16482

16483

                                                    if let &Opcode::Fcmp = v665 {

16484

                                                        if let &FloatCC::LessThan = v667 {

16485

                                                            let v668 =

16486

                                                                C::unpack_value_array_2(ctx, v666);

16487

                                                            if v636.1 == v668.1 {

16488

                                                                if v636.2 == v668.0 {

16489

                                                                    let v677 =

16490

                                                                        constructor_put_in_xmm(

16491

                                                                            ctx, v668.1,

16492

);

16493

                                                                    let v678 = &C::put_in_xmm_mem(

16494

                                                                        ctx, v668.0,

16495

);

16496

                                                                    let v681 =

16497

                                                                        constructor_x64_maxpd(

16498

                                                                            ctx, v677, v678,

16499

);

16500

                                                                    let v682 =

16501

                                                                        constructor_output_xmm(

16502

                                                                            ctx, v681,

16503

);

16504

                                                                    // Rule at src/isa/x64/lower.isle line 1422.

16505

                                                                    return Some(v682);

16506

16507

16508

                                                            if v636.1 == v668.0 {

16509

                                                                if v636.2 == v668.1 {

16510

                                                                    let v671 =

16511

                                                                        constructor_put_in_xmm(

16512

                                                                            ctx, v668.0,

16513

);

16514

                                                                    let v672 = &C::put_in_xmm_mem(

16515

                                                                        ctx, v668.1,

16516

);

16517

                                                                    let v675 =

16518

                                                                        constructor_x64_minpd(

16519

                                                                            ctx, v671, v672,

16520

);

16521

                                                                    let v676 =

16522

                                                                        constructor_output_xmm(

16523

                                                                            ctx, v675,

16524

);

16525

                                                                    // Rule at src/isa/x64/lower.isle line 1417.

16526

                                                                    return Some(v676);

16527

16528

16529

16530

16531

16532

16533

16534

16535

16536

16537

                            _ => {}

16538

16539

                        let v64 = C::multi_lane(ctx, v3);

16540

                        if let Some(v65) = v64 {

16541

                            let v441 = C::use_sse41(ctx);

16542

                            if v441 == true {

16543

                                let v636 = C::unpack_value_array_3(ctx, v635);

16544

                                let v649 = constructor_all_ones_or_all_zeros(ctx, v636.0);

16545

                                if let Some(v650) = v649 {

16546

                                    let v651 = constructor_put_in_xmm(ctx, v636.2);

16547

                                    let v652 = &C::put_in_xmm_mem(ctx, v636.1);

16548

                                    let v653 = constructor_put_in_xmm(ctx, v636.0);

16549

                                    let v654 = constructor_x64_pblendvb(ctx, v651, v652, v653);

16550

                                    let v655 = constructor_output_xmm(ctx, v654);

16551

                                    // Rule at src/isa/x64/lower.isle line 1394.

16552

                                    return Some(v655);

16553

16554

16555

                            let v636 = C::unpack_value_array_3(ctx, v635);

16556

                            let v640 = constructor_put_in_xmm(ctx, v636.0);

16557

                            let v641 = constructor_put_in_xmm(ctx, v636.1);

16558

                            let v642 = &C::xmm_to_xmm_mem(ctx, v640);

16559

                            let v643 = constructor_sse_and(ctx, v3, v641, v642);

16560

                            let v644 = &C::put_in_xmm_mem(ctx, v636.2);

16561

                            let v645 = constructor_sse_and_not(ctx, v3, v640, v644);

16562

                            let v646 = &C::xmm_to_xmm_mem(ctx, v643);

16563

                            let v647 = constructor_sse_or(ctx, v3, v645, v646);

16564

                            let v648 = constructor_output_xmm(ctx, v647);

16565

                            // Rule at src/isa/x64/lower.isle line 1380.

16566

                            return Some(v648);

16567

16568

16569

16570

                &Opcode::X86Blendv => {

16571

                    let v1 = C::first_result(ctx, arg0);

16572

                    if let Some(v2) = v1 {

16573

                        let v3 = C::value_type(ctx, v2);

16574

                        match v3 {

16575

                            I8X16 => {

16576

                                let v441 = C::use_sse41(ctx);

16577

                                if v441 == true {

16578

                                    let v636 = C::unpack_value_array_3(ctx, v635);

16579

                                    let v651 = constructor_put_in_xmm(ctx, v636.2);

16580

                                    let v652 = &C::put_in_xmm_mem(ctx, v636.1);

16581

                                    let v653 = constructor_put_in_xmm(ctx, v636.0);

16582

                                    let v654 = constructor_x64_pblendvb(ctx, v651, v652, v653);

16583

                                    let v655 = constructor_output_xmm(ctx, v654);

16584

                                    // Rule at src/isa/x64/lower.isle line 1445.

16585

                                    return Some(v655);

16586

16587

16588

                            I32X4 => {

16589

                                let v441 = C::use_sse41(ctx);

16590

                                if v441 == true {

16591

                                    let v636 = C::unpack_value_array_3(ctx, v635);

16592

                                    let v651 = constructor_put_in_xmm(ctx, v636.2);

16593

                                    let v652 = &C::put_in_xmm_mem(ctx, v636.1);

16594

                                    let v653 = constructor_put_in_xmm(ctx, v636.0);

16595

                                    let v713 = constructor_x64_blendvps(ctx, v651, v652, v653);

16596

                                    let v714 = constructor_output_xmm(ctx, v713);

16597

                                    // Rule at src/isa/x64/lower.isle line 1450.

16598

                                    return Some(v714);

16599

16600

16601

                            I64X2 => {

16602

                                let v441 = C::use_sse41(ctx);

16603

                                if v441 == true {

16604

                                    let v636 = C::unpack_value_array_3(ctx, v635);

16605

                                    let v651 = constructor_put_in_xmm(ctx, v636.2);

16606

                                    let v652 = &C::put_in_xmm_mem(ctx, v636.1);

16607

                                    let v653 = constructor_put_in_xmm(ctx, v636.0);

16608

                                    let v715 = constructor_x64_blendvpd(ctx, v651, v652, v653);

16609

                                    let v716 = constructor_output_xmm(ctx, v715);

16610

                                    // Rule at src/isa/x64/lower.isle line 1455.

16611

                                    return Some(v716);

16612

16613

16614

                            _ => {}

16615

16616

16617

16618

                &Opcode::Fma => {

16619

                    let v1 = C::first_result(ctx, arg0);

16620

                    if let Some(v2) = v1 {

16621

                        let v1470 = C::use_fma(ctx);

16622

                        if v1470 == true {

16623

                            let v3 = C::value_type(ctx, v2);

16624

                            let v636 = C::unpack_value_array_3(ctx, v635);

16625

                            let v1471 = constructor_fmadd(ctx, v3, v636.0, v636.1, v636.2);

16626

                            let v1472 = constructor_output_xmm(ctx, v1471);

16627

                            // Rule at src/isa/x64/lower.isle line 2799.

16628

                            return Some(v1472);

16629

16630

                        let v3 = C::value_type(ctx, v2);

16631

                        match v3 {

16632

                            F32 => {

16633

                                let v636 = C::unpack_value_array_3(ctx, v635);

16634

                                let v1389 = C::put_in_reg(ctx, v636.0);

16635

                                let v1390 = C::put_in_reg(ctx, v636.1);

16636

                                let v1391 = C::put_in_reg(ctx, v636.2);

16637

                                let v1392 =

16638

                                    C::libcall_3(ctx, &LibCall::FmaF32, v1389, v1390, v1391);

16639

                                let v1393 = constructor_output_reg(ctx, v1392);

16640

                                // Rule at src/isa/x64/lower.isle line 2754.

16641

                                return Some(v1393);

16642

16643

                            F64 => {

16644

                                let v636 = C::unpack_value_array_3(ctx, v635);

16645

                                let v1389 = C::put_in_reg(ctx, v636.0);

16646

                                let v1390 = C::put_in_reg(ctx, v636.1);

16647

                                let v1391 = C::put_in_reg(ctx, v636.2);

16648

                                let v1395 =

16649

                                    C::libcall_3(ctx, &LibCall::FmaF64, v1389, v1390, v1391);

16650

                                let v1396 = constructor_output_reg(ctx, v1395);

16651

                                // Rule at src/isa/x64/lower.isle line 2756.

16652

                                return Some(v1396);

16653

16654

                            F32X4 => {

16655

                                let v636 = C::unpack_value_array_3(ctx, v635);

16656

                                let v640 = constructor_put_in_xmm(ctx, v636.0);

16657

                                let v641 = constructor_put_in_xmm(ctx, v636.1);

16658

                                let v1397 = constructor_put_in_xmm(ctx, v636.2);

16659

                                let v1398 = C::xmm_to_reg(ctx, v640);

16660

                                let v1399 = C::xmm_to_reg(ctx, v641);

16661

                                let v1400 = C::xmm_to_reg(ctx, v1397);

16662

                                let v1401 =

16663

                                    C::libcall_3(ctx, &LibCall::FmaF32, v1398, v1399, v1400);

16664

                                let v1402 = C::xmm_new(ctx, v1401);

16665

                                let v1403 = &C::xmm_to_xmm_mem(ctx, v640);

16666

                                let v1405 = constructor_x64_pshufd(ctx, v1403, 0x1);

16667

                                let v1406 = C::xmm_to_reg(ctx, v1405);

16668

                                let v1407 = &C::xmm_to_xmm_mem(ctx, v641);

16669

                                let v1408 = constructor_x64_pshufd(ctx, v1407, 0x1);

16670

                                let v1409 = C::xmm_to_reg(ctx, v1408);

16671

                                let v1410 = &C::xmm_to_xmm_mem(ctx, v1397);

16672

                                let v1411 = constructor_x64_pshufd(ctx, v1410, 0x1);

16673

                                let v1412 = C::xmm_to_reg(ctx, v1411);

16674

                                let v1413 =

16675

                                    C::libcall_3(ctx, &LibCall::FmaF32, v1406, v1409, v1412);

16676

                                let v1414 = C::xmm_new(ctx, v1413);

16677

                                let v1415 = &C::xmm_to_xmm_mem(ctx, v640);

16678

                                let v1417 = constructor_x64_pshufd(ctx, v1415, 0x2);

16679

                                let v1418 = C::xmm_to_reg(ctx, v1417);

16680

                                let v1419 = &C::xmm_to_xmm_mem(ctx, v641);

16681

                                let v1420 = constructor_x64_pshufd(ctx, v1419, 0x2);

16682

                                let v1421 = C::xmm_to_reg(ctx, v1420);

16683

                                let v1422 = &C::xmm_to_xmm_mem(ctx, v1397);

16684

                                let v1423 = constructor_x64_pshufd(ctx, v1422, 0x2);

16685

                                let v1424 = C::xmm_to_reg(ctx, v1423);

16686

                                let v1425 =

16687

                                    C::libcall_3(ctx, &LibCall::FmaF32, v1418, v1421, v1424);

16688

                                let v1426 = C::xmm_new(ctx, v1425);

16689

                                let v1427 = &C::xmm_to_xmm_mem(ctx, v640);

16690

                                let v1429 = constructor_x64_pshufd(ctx, v1427, 0x3);

16691

                                let v1430 = C::xmm_to_reg(ctx, v1429);

16692

                                let v1431 = &C::xmm_to_xmm_mem(ctx, v641);

16693

                                let v1432 = constructor_x64_pshufd(ctx, v1431, 0x3);

16694

                                let v1433 = C::xmm_to_reg(ctx, v1432);

16695

                                let v1434 = &C::xmm_to_xmm_mem(ctx, v1397);

16696

                                let v1435 = constructor_x64_pshufd(ctx, v1434, 0x3);

16697

                                let v1436 = C::xmm_to_reg(ctx, v1435);

16698

                                let v1437 =

16699

                                    C::libcall_3(ctx, &LibCall::FmaF32, v1430, v1433, v1436);

16700

                                let v1438 = C::xmm_new(ctx, v1437);

16701

                                let v1440 = C::xmm_to_reg(ctx, v1414);

16702

                                let v1441 = &constructor_xmm_to_reg_mem(ctx, v1440);

16703

                                let v1442 = &C::xmm_mem_to_reg_mem(ctx, v1441);

16704

                                let v1443 =

16705

                                    constructor_vec_insert_lane(ctx, F32X4, v1402, v1442, 0x1);

16706

                                let v1444 = C::xmm_to_reg(ctx, v1426);

16707

                                let v1445 = &constructor_xmm_to_reg_mem(ctx, v1444);

16708

                                let v1446 = &C::xmm_mem_to_reg_mem(ctx, v1445);

16709

                                let v1447 =

16710

                                    constructor_vec_insert_lane(ctx, F32X4, v1443, v1446, 0x2);

16711

                                let v1448 = C::xmm_to_reg(ctx, v1438);

16712

                                let v1449 = &constructor_xmm_to_reg_mem(ctx, v1448);

16713

                                let v1450 = &C::xmm_mem_to_reg_mem(ctx, v1449);

16714

                                let v1451 =

16715

                                    constructor_vec_insert_lane(ctx, F32X4, v1447, v1450, 0x3);

16716

                                let v1452 = constructor_output_xmm(ctx, v1451);

16717

                                // Rule at src/isa/x64/lower.isle line 2759.

16718

                                return Some(v1452);

16719

16720

                            F64X2 => {

16721

                                let v636 = C::unpack_value_array_3(ctx, v635);

16722

                                let v640 = constructor_put_in_xmm(ctx, v636.0);

16723

                                let v641 = constructor_put_in_xmm(ctx, v636.1);

16724

                                let v1397 = constructor_put_in_xmm(ctx, v636.2);

16725

                                let v1398 = C::xmm_to_reg(ctx, v640);

16726

                                let v1399 = C::xmm_to_reg(ctx, v641);

16727

                                let v1400 = C::xmm_to_reg(ctx, v1397);

16728

                                let v1453 =

16729

                                    C::libcall_3(ctx, &LibCall::FmaF64, v1398, v1399, v1400);

16730

                                let v1454 = C::xmm_new(ctx, v1453);

16731

                                let v1403 = &C::xmm_to_xmm_mem(ctx, v640);

16732

                                let v1456 = constructor_x64_pshufd(ctx, v1403, 0xEE);

16733

                                let v1457 = C::xmm_to_reg(ctx, v1456);

16734

                                let v1407 = &C::xmm_to_xmm_mem(ctx, v641);

16735

                                let v1458 = constructor_x64_pshufd(ctx, v1407, 0xEE);

16736

                                let v1459 = C::xmm_to_reg(ctx, v1458);

16737

                                let v1410 = &C::xmm_to_xmm_mem(ctx, v1397);

16738

                                let v1460 = constructor_x64_pshufd(ctx, v1410, 0xEE);

16739

                                let v1461 = C::xmm_to_reg(ctx, v1460);

16740

                                let v1462 =

16741

                                    C::libcall_3(ctx, &LibCall::FmaF64, v1457, v1459, v1461);

16742

                                let v1463 = C::xmm_new(ctx, v1462);

16743

                                let v1465 = C::xmm_to_reg(ctx, v1463);

16744

                                let v1466 = &constructor_xmm_to_reg_mem(ctx, v1465);

16745

                                let v1467 = &C::xmm_mem_to_reg_mem(ctx, v1466);

16746

                                let v1468 =

16747

                                    constructor_vec_insert_lane(ctx, F64X2, v1454, v1467, 0x1);

16748

                                let v1469 = constructor_output_xmm(ctx, v1468);

16749

                                // Rule at src/isa/x64/lower.isle line 2783.

16750

                                return Some(v1469);

16751

16752

                            _ => {}

16753

16754

16755

16756

                _ => {}

16757

16758

16759

        &InstructionData::TernaryImm8 {

16760

            opcode: ref v717,

16761

            args: ref v718,

16762

            imm: v719,

16763

        } => {

16764

            if let &Opcode::Insertlane = v717 {

16765

                let v720 = C::unpack_value_array_2(ctx, v718);

16766

                let v725 = constructor_put_in_xmm(ctx, v720.0);

16767

                let v726 = &C::put_in_reg_mem(ctx, v720.1);

16768

                let v723 = C::value_type(ctx, v720.0);

16769

                let v724 = C::u8_from_uimm8(ctx, v719);

16770

                let v727 = constructor_vec_insert_lane(ctx, v723, v725, v726, v724);

16771

                let v728 = constructor_output_xmm(ctx, v727);

16772

                // Rule at src/isa/x64/lower.isle line 1462.

16773

                return Some(v728);

16774

16775

16776

        &InstructionData::Trap {

16777

            opcode: ref v787,

16778

            code: ref v788,

16779

        } => {

16780

            match v787 {

16781

                &Opcode::Trap => {

16782

                    let v789 = &constructor_x64_ud2(ctx, v788);

16783

                    let v790 = constructor_side_effect(ctx, v789);

16784

                    // Rule at src/isa/x64/lower.isle line 1765.

16785

                    return Some(v790);

16786

16787

                &Opcode::ResumableTrap => {

16788

                    let v789 = &constructor_x64_ud2(ctx, v788);

16789

                    let v790 = constructor_side_effect(ctx, v789);

16790

                    // Rule at src/isa/x64/lower.isle line 1792.

16791

                    return Some(v790);

16792

16793

                _ => {}

16794

16795

16796

        &InstructionData::Unary {

16797

            opcode: ref v380,

16798

            arg: v381,

16799

        } => {

16800

            match v380 {

16801

                &Opcode::Splat => {

16802

                    let v1 = C::first_result(ctx, arg0);

16803

                    if let Some(v2) = v1 {

16804

                        let v3 = C::value_type(ctx, v2);

16805

                        let v64 = C::multi_lane(ctx, v3);

16806

                        if let Some(v65) = v64 {

16807

                            match v65.0 {

16808

                                0x20 => {

16809

                                    if v65.1 == 0x4 {

16810

                                        let v2402 = &C::sinkable_load(ctx, v381);

16811

                                        if let Some(v2403) = v2402 {

16812

                                            let v2468 = C::use_avx(ctx);

16813

                                            if v2468 == true {

16814

                                                let v2469 =

16815

                                                    &constructor_sink_load_to_xmm_mem(ctx, v2403);

16816

                                                let v2470 =

16817

                                                    constructor_x64_vbroadcastss(ctx, v2469);

16818

                                                let v2471 = constructor_output_xmm(ctx, v2470);

16819

                                                // Rule at src/isa/x64/lower.isle line 4521.

16820

                                                return Some(v2471);

16821

16822

                                            let v2406 = &C::sink_load(ctx, v2403);

16823

                                            let v2407 = constructor_x64_movss_load(ctx, v2406);

16824

                                            let v2465 = &C::xmm_to_xmm_mem(ctx, v2407);

16825

                                            let v2466 =

16826

                                                constructor_x64_shufps(ctx, v2407, v2465, 0x0);

16827

                                            let v2467 = constructor_output_xmm(ctx, v2466);

16828

                                            // Rule at src/isa/x64/lower.isle line 4518.

16829

                                            return Some(v2467);

16830

16831

16832

16833

                                0x40 => {

16834

                                    if v65.1 == 0x2 {

16835

                                        let v525 = C::use_ssse3(ctx);

16836

                                        if v525 == true {

16837

                                            let v2402 = &C::sinkable_load(ctx, v381);

16838

                                            if let Some(v2403) = v2402 {

16839

                                                let v2469 =

16840

                                                    &constructor_sink_load_to_xmm_mem(ctx, v2403);

16841

                                                let v2479 = constructor_x64_movddup(ctx, v2469);

16842

                                                let v2480 = constructor_output_xmm(ctx, v2479);

16843

                                                // Rule at src/isa/x64/lower.isle line 4532.

16844

                                                return Some(v2480);

16845

16846

16847

16848

16849

                                _ => {}

16850

16851

16852

                        match v3 {

16853

                            I8X16 => {

16854

                                let v2432 = &C::sinkable_load_exact(ctx, v381);

16855

                                if let Some(v2433) = v2432 {

16856

                                    let v2428 = C::use_avx2(ctx);

16857

                                    if v2428 == true {

16858

                                        let v2439 = &constructor_sink_load_to_xmm_mem(ctx, v2433);

16859

                                        let v2440 = constructor_x64_vpbroadcastb(ctx, v2439);

16860

                                        let v2441 = constructor_output_xmm(ctx, v2440);

16861

                                        // Rule at src/isa/x64/lower.isle line 4469.

16862

                                        return Some(v2441);

16863

16864

                                    let v441 = C::use_sse41(ctx);

16865

                                    if v441 == true {

16866

                                        let v525 = C::use_ssse3(ctx);

16867

                                        if v525 == true {

16868

                                            let v2434 = constructor_xmm_uninit_value(ctx);

16869

                                            let v2435 =

16870

                                                &constructor_sink_load_to_gpr_mem(ctx, v2433);

16871

                                            let v2436 =

16872

                                                constructor_x64_pinsrb(ctx, v2434, v2435, 0x0);

16873

                                            let v951 = constructor_xmm_zero(ctx, I8X16);

16874

                                            let v952 = &C::xmm_to_xmm_mem(ctx, v951);

16875

                                            let v2437 = constructor_x64_pshufb(ctx, v2436, v952);

16876

                                            let v2438 = constructor_output_xmm(ctx, v2437);

16877

                                            // Rule at src/isa/x64/lower.isle line 4465.

16878

                                            return Some(v2438);

16879

16880

16881

16882

                                let v2428 = C::use_avx2(ctx);

16883

                                if v2428 == true {

16884

                                    let v382 = constructor_put_in_gpr(ctx, v381);

16885

                                    let v2423 = constructor_bitcast_gpr_to_xmm(ctx, I32, v382);

16886

                                    let v2429 = &C::xmm_to_xmm_mem(ctx, v2423);

16887

                                    let v2430 = constructor_x64_vpbroadcastb(ctx, v2429);

16888

                                    let v2431 = constructor_output_xmm(ctx, v2430);

16889

                                    // Rule at src/isa/x64/lower.isle line 4462.

16890

                                    return Some(v2431);

16891

16892

                                let v525 = C::use_ssse3(ctx);

16893

                                if v525 == true {

16894

                                    let v382 = constructor_put_in_gpr(ctx, v381);

16895

                                    let v2423 = constructor_bitcast_gpr_to_xmm(ctx, I32, v382);

16896

                                    let v2424 = constructor_xmm_zero(ctx, I8X16);

16897

                                    let v2425 = &C::xmm_to_xmm_mem(ctx, v2424);

16898

                                    let v2426 = constructor_x64_pshufb(ctx, v2423, v2425);

16899

                                    let v2427 = constructor_output_xmm(ctx, v2426);

16900

                                    // Rule at src/isa/x64/lower.isle line 4459.

16901

                                    return Some(v2427);

16902

16903

                                let v2413 = &constructor_put_in_gpr_mem(ctx, v381);

16904

                                let v2414 = constructor_x64_movd_to_xmm(ctx, v2413);

16905

                                let v2415 = &C::xmm_to_xmm_mem(ctx, v2414);

16906

                                let v2416 = constructor_x64_punpcklbw(ctx, v2414, v2415);

16907

                                let v2417 = &C::xmm_to_xmm_mem(ctx, v2416);

16908

                                let v2419 = constructor_x64_pshuflw(ctx, v2417, 0x0);

16909

                                let v2420 = &C::xmm_to_xmm_mem(ctx, v2419);

16910

                                let v2421 = constructor_x64_pshufd(ctx, v2420, 0x0);

16911

                                let v2422 = constructor_output_xmm(ctx, v2421);

16912

                                // Rule at src/isa/x64/lower.isle line 4456.

16913

                                return Some(v2422);

16914

16915

                            I16X8 => {

16916

                                let v2432 = &C::sinkable_load_exact(ctx, v381);

16917

                                if let Some(v2433) = v2432 {

16918

                                    let v2428 = C::use_avx2(ctx);

16919

                                    if v2428 == true {

16920

                                        let v2439 = &constructor_sink_load_to_xmm_mem(ctx, v2433);

16921

                                        let v2454 = constructor_x64_vpbroadcastw(ctx, v2439);

16922

                                        let v2455 = constructor_output_xmm(ctx, v2454);

16923

                                        // Rule at src/isa/x64/lower.isle line 4485.

16924

                                        return Some(v2455);

16925

16926

                                    let v2434 = constructor_xmm_uninit_value(ctx);

16927

                                    let v2435 = &constructor_sink_load_to_gpr_mem(ctx, v2433);

16928

                                    let v2448 = constructor_x64_pinsrw(ctx, v2434, v2435, 0x0);

16929

                                    let v2449 = &C::xmm_to_xmm_mem(ctx, v2448);

16930

                                    let v2450 = constructor_x64_pshuflw(ctx, v2449, 0x0);

16931

                                    let v2451 = &C::xmm_to_xmm_mem(ctx, v2450);

16932

                                    let v2452 = constructor_x64_pshufd(ctx, v2451, 0x0);

16933

                                    let v2453 = constructor_output_xmm(ctx, v2452);

16934

                                    // Rule at src/isa/x64/lower.isle line 4483.

16935

                                    return Some(v2453);

16936

16937

                                let v2428 = C::use_avx2(ctx);

16938

                                if v2428 == true {

16939

                                    let v382 = constructor_put_in_gpr(ctx, v381);

16940

                                    let v2423 = constructor_bitcast_gpr_to_xmm(ctx, I32, v382);

16941

                                    let v2429 = &C::xmm_to_xmm_mem(ctx, v2423);

16942

                                    let v2446 = constructor_x64_vpbroadcastw(ctx, v2429);

16943

                                    let v2447 = constructor_output_xmm(ctx, v2446);

16944

                                    // Rule at src/isa/x64/lower.isle line 4480.

16945

                                    return Some(v2447);

16946

16947

                                let v382 = constructor_put_in_gpr(ctx, v381);

16948

                                let v2423 = constructor_bitcast_gpr_to_xmm(ctx, I32, v382);

16949

                                let v2429 = &C::xmm_to_xmm_mem(ctx, v2423);

16950

                                let v2442 = constructor_x64_pshuflw(ctx, v2429, 0x0);

16951

                                let v2443 = &C::xmm_to_xmm_mem(ctx, v2442);

16952

                                let v2444 = constructor_x64_pshufd(ctx, v2443, 0x0);

16953

                                let v2445 = constructor_output_xmm(ctx, v2444);

16954

                                // Rule at src/isa/x64/lower.isle line 4478.

16955

                                return Some(v2445);

16956

16957

                            I32X4 => {

16958

                                let v2428 = C::use_avx2(ctx);

16959

                                if v2428 == true {

16960

                                    let v382 = constructor_put_in_gpr(ctx, v381);

16961

                                    let v2423 = constructor_bitcast_gpr_to_xmm(ctx, I32, v382);

16962

                                    let v2429 = &C::xmm_to_xmm_mem(ctx, v2423);

16963

                                    let v2458 = constructor_x64_vpbroadcastd(ctx, v2429);

16964

                                    let v2459 = constructor_output_xmm(ctx, v2458);

16965

                                    // Rule at src/isa/x64/lower.isle line 4495.

16966

                                    return Some(v2459);

16967

16968

                                let v382 = constructor_put_in_gpr(ctx, v381);

16969

                                let v2423 = constructor_bitcast_gpr_to_xmm(ctx, I32, v382);

16970

                                let v2429 = &C::xmm_to_xmm_mem(ctx, v2423);

16971

                                let v2456 = constructor_x64_pshufd(ctx, v2429, 0x0);

16972

                                let v2457 = constructor_output_xmm(ctx, v2456);

16973

                                // Rule at src/isa/x64/lower.isle line 4493.

16974

                                return Some(v2457);

16975

16976

                            I64X2 => {

16977

                                let v382 = constructor_put_in_gpr(ctx, v381);

16978

                                let v2472 = constructor_bitcast_gpr_to_xmm(ctx, I64, v382);

16979

                                let v2473 = &C::xmm_to_xmm_mem(ctx, v2472);

16980

                                let v2475 = constructor_x64_pshufd(ctx, v2473, 0x44);

16981

                                let v2476 = constructor_output_xmm(ctx, v2475);

16982

                                // Rule at src/isa/x64/lower.isle line 4528.

16983

                                return Some(v2476);

16984

16985

                            F32X4 => {

16986

                                let v2428 = C::use_avx2(ctx);

16987

                                if v2428 == true {

16988

                                    let v526 = &C::put_in_xmm_mem(ctx, v381);

16989

                                    let v2463 = constructor_x64_vbroadcastss(ctx, v526);

16990

                                    let v2464 = constructor_output_xmm(ctx, v2463);

16991

                                    // Rule at src/isa/x64/lower.isle line 4505.

16992

                                    return Some(v2464);

16993

16994

                                let v529 = constructor_put_in_xmm(ctx, v381);

16995

                                let v2460 = constructor_put_in_xmm(ctx, v381);

16996

                                let v397 = &C::put_in_xmm_mem(ctx, v381);

16997

                                let v2461 = constructor_x64_shufps(ctx, v2460, v397, 0x0);

16998

                                let v2462 = constructor_output_xmm(ctx, v2461);

16999

                                // Rule at src/isa/x64/lower.isle line 4502.

17000

                                return Some(v2462);

17001

17002

                            F64X2 => {

17003

                                let v526 = &C::put_in_xmm_mem(ctx, v381);

17004

                                let v2477 = constructor_x64_pshufd(ctx, v526, 0x44);

17005

                                let v2478 = constructor_output_xmm(ctx, v2477);

17006

                                // Rule at src/isa/x64/lower.isle line 4530.

17007

                                return Some(v2478);

17008

17009

                            _ => {}

17010

17011

17012

17013

                &Opcode::SetPinnedReg => {

17014

                    let v382 = constructor_put_in_gpr(ctx, v381);

17015

                    let v2240 = &constructor_write_pinned_gpr(ctx, v382);

17016

                    let v2241 = constructor_side_effect(ctx, v2240);

17017

                    // Rule at src/isa/x64/lower.isle line 4177.

17018

                    return Some(v2241);

17019

17020

                &Opcode::VanyTrue => {

17021

                    let v441 = C::use_sse41(ctx);

17022

                    if v441 == true {

17023

                        let v529 = constructor_put_in_xmm(ctx, v381);

17024

                        let v1311 = &C::xmm_to_xmm_mem(ctx, v529);

17025

                        let v2481 = &constructor_x64_ptest(ctx, v1311, v529);

17026

                        let v2482 = &constructor_x64_setcc(ctx, &CC::NZ);

17027

                        let v2483 = constructor_with_flags(ctx, v2481, v2482);

17028

                        let v2484 = C::output(ctx, v2483);

17029

                        // Rule at src/isa/x64/lower.isle line 4538.

17030

                        return Some(v2484);

17031

17032

                    let v529 = constructor_put_in_xmm(ctx, v381);

17033

                    let v530 = constructor_xmm_zero(ctx, I8X16);

17034

                    let v2073 = &C::xmm_to_xmm_mem(ctx, v530);

17035

                    let v2485 = constructor_x64_pcmpeqb(ctx, v529, v2073);

17036

                    let v2487 = constructor_x64_pmovmskb(ctx, &OperandSize::Size32, v2485);

17037

                    let v2489 = RegMemImm::Imm { simm32: 0xFFFF };

17038

                    let v2490 = &C::gpr_mem_imm_new(ctx, &v2489);

17039

                    let v2491 = &constructor_x64_cmp(ctx, &OperandSize::Size32, v2490, v2487);

17040

                    let v2492 = &constructor_x64_setcc(ctx, &CC::NZ);

17041

                    let v2493 = constructor_with_flags(ctx, v2491, v2492);

17042

                    let v2494 = C::output(ctx, v2493);

17043

                    // Rule at src/isa/x64/lower.isle line 4547.

17044

                    return Some(v2494);

17045

17046

                &Opcode::VallTrue => {

17047

                    let v441 = C::use_sse41(ctx);

17048

                    if v441 == true {

17049

                        let v529 = constructor_put_in_xmm(ctx, v381);

17050

                        let v622 = C::value_type(ctx, v381);

17051

                        let v2495 = constructor_xmm_zero(ctx, v622);

17052

                        let v2496 = constructor_vec_int_type(ctx, v622);

17053

                        let v2497 = &C::xmm_to_xmm_mem(ctx, v2495);

17054

                        let v2498 = constructor_x64_pcmpeq(ctx, v2496, v529, v2497);

17055

                        let v2499 = &C::xmm_to_xmm_mem(ctx, v2498);

17056

                        let v2500 = &constructor_x64_ptest(ctx, v2499, v2498);

17057

                        let v2501 = &constructor_x64_setcc(ctx, &CC::Z);

17058

                        let v2502 = constructor_with_flags(ctx, v2500, v2501);

17059

                        let v2503 = C::output(ctx, v2502);

17060

                        // Rule at src/isa/x64/lower.isle line 4557.

17061

                        return Some(v2503);

17062

17063

                    let v622 = C::value_type(ctx, v381);

17064

                    let v2504 = constructor_vec_int_type(ctx, v622);

17065

                    let v2460 = constructor_put_in_xmm(ctx, v381);

17066

                    let v2505 = constructor_xmm_zero(ctx, v622);

17067

                    let v2506 = &C::xmm_to_xmm_mem(ctx, v2505);

17068

                    let v2507 = constructor_x64_pcmpeq(ctx, v2504, v2460, v2506);

17069

                    let v2508 = constructor_x64_pmovmskb(ctx, &OperandSize::Size32, v2507);

17070

                    let v2509 = &C::gpr_to_gpr_mem_imm(ctx, v2508);

17071

                    let v2510 = &constructor_x64_test(ctx, &OperandSize::Size32, v2509, v2508);

17072

                    let v2511 = &constructor_x64_setcc(ctx, &CC::Z);

17073

                    let v2512 = constructor_with_flags(ctx, v2510, v2511);

17074

                    let v2513 = C::output(ctx, v2512);

17075

                    // Rule at src/isa/x64/lower.isle line 4567.

17076

                    return Some(v2513);

17077

17078

                &Opcode::VhighBits => {

17079

                    let v622 = C::value_type(ctx, v381);

17080

                    let v2514 = C::multi_lane(ctx, v622);

17081

                    if let Some(v2515) = v2514 {

17082

                        match v2515.0 {

17083

                            0x8 => {

17084

                                if v2515.1 == 0x10 {

17085

                                    let v529 = constructor_put_in_xmm(ctx, v381);

17086

                                    let v2518 =

17087

                                        constructor_x64_pmovmskb(ctx, &OperandSize::Size32, v529);

17088

                                    let v2519 = constructor_output_gpr(ctx, v2518);

17089

                                    // Rule at src/isa/x64/lower.isle line 4584.

17090

                                    return Some(v2519);

17091

17092

17093

                            0x10 => {

17094

                                if v2515.1 == 0x8 {

17095

                                    let v529 = constructor_put_in_xmm(ctx, v381);

17096

                                    let v1311 = &C::xmm_to_xmm_mem(ctx, v529);

17097

                                    let v2524 = constructor_x64_packsswb(ctx, v529, v1311);

17098

                                    let v2525 =

17099

                                        constructor_x64_pmovmskb(ctx, &OperandSize::Size32, v2524);

17100

                                    let v1204 = Imm8Reg::Imm8 { imm: 0x8 };

17101

                                    let v2192 = &C::imm8_reg_to_imm8_gpr(ctx, &v1204);

17102

                                    let v2526 = constructor_x64_shr(ctx, I64, v2525, v2192);

17103

                                    let v2527 = constructor_output_gpr(ctx, v2526);

17104

                                    // Rule at src/isa/x64/lower.isle line 4599.

17105

                                    return Some(v2527);

17106

17107

17108

                            0x20 => {

17109

                                if v2515.1 == 0x4 {

17110

                                    let v529 = constructor_put_in_xmm(ctx, v381);

17111

                                    let v2520 =

17112

                                        constructor_x64_movmskps(ctx, &OperandSize::Size32, v529);

17113

                                    let v2521 = constructor_output_gpr(ctx, v2520);

17114

                                    // Rule at src/isa/x64/lower.isle line 4587.

17115

                                    return Some(v2521);

17116

17117

17118

                            0x40 => {

17119

                                if v2515.1 == 0x2 {

17120

                                    let v529 = constructor_put_in_xmm(ctx, v381);

17121

                                    let v2522 =

17122

                                        constructor_x64_movmskpd(ctx, &OperandSize::Size32, v529);

17123

                                    let v2523 = constructor_output_gpr(ctx, v2522);

17124

                                    // Rule at src/isa/x64/lower.isle line 4590.

17125

                                    return Some(v2523);

17126

17127

17128

                            _ => {}

17129

17130

17131

17132

                &Opcode::Ineg => {

17133

                    let v1 = C::first_result(ctx, arg0);

17134

                    if let Some(v2) = v1 {

17135

                        let v3 = C::value_type(ctx, v2);

17136

                        match v3 {

17137

                            I8X16 => {

17138

                                let v395 = constructor_imm(ctx, I8X16, 0x0);

17139

                                let v396 = C::xmm_new(ctx, v395);

17140

                                let v397 = &C::put_in_xmm_mem(ctx, v381);

17141

                                let v398 = constructor_x64_psubb(ctx, v396, v397);

17142

                                let v399 = constructor_output_xmm(ctx, v398);

17143

                                // Rule at src/isa/x64/lower.isle line 942.

17144

                                return Some(v399);

17145

17146

                            I16X8 => {

17147

                                let v401 = constructor_imm(ctx, I16X8, 0x0);

17148

                                let v402 = C::xmm_new(ctx, v401);

17149

                                let v397 = &C::put_in_xmm_mem(ctx, v381);

17150

                                let v403 = constructor_x64_psubw(ctx, v402, v397);

17151

                                let v404 = constructor_output_xmm(ctx, v403);

17152

                                // Rule at src/isa/x64/lower.isle line 945.

17153

                                return Some(v404);

17154

17155

                            I32X4 => {

17156

                                let v406 = constructor_imm(ctx, I32X4, 0x0);

17157

                                let v407 = C::xmm_new(ctx, v406);

17158

                                let v397 = &C::put_in_xmm_mem(ctx, v381);

17159

                                let v408 = constructor_x64_psubd(ctx, v407, v397);

17160

                                let v409 = constructor_output_xmm(ctx, v408);

17161

                                // Rule at src/isa/x64/lower.isle line 948.

17162

                                return Some(v409);

17163

17164

                            I64X2 => {

17165

                                let v411 = constructor_imm(ctx, I64X2, 0x0);

17166

                                let v412 = C::xmm_new(ctx, v411);

17167

                                let v397 = &C::put_in_xmm_mem(ctx, v381);

17168

                                let v413 = constructor_x64_psubq(ctx, v412, v397);

17169

                                let v414 = constructor_output_xmm(ctx, v413);

17170

                                // Rule at src/isa/x64/lower.isle line 951.

17171

                                return Some(v414);

17172

17173

                            _ => {}

17174

17175

                        let v4 = C::fits_in_64(ctx, v3);

17176

                        if let Some(v5) = v4 {

17177

                            let v382 = constructor_put_in_gpr(ctx, v381);

17178

                            let v383 = constructor_x64_neg(ctx, v5, v382);

17179

                            let v384 = constructor_output_gpr(ctx, v383);

17180

                            // Rule at src/isa/x64/lower.isle line 928.

17181

                            return Some(v384);

17182

17183

                        if v3 == I128 {

17184

                            let v385 = C::put_in_regs(ctx, v381);

17185

                            let v386 = constructor_value_regs_get_gpr(ctx, v385, 0x0);

17186

                            let v387 = constructor_value_regs_get_gpr(ctx, v385, 0x1);

17187

                            let v388 = &constructor_x64_neg_paired(ctx, I64, v386);

17188

                            let v389 = constructor_imm(ctx, I64, 0x0);

17189

                            let v390 = C::gpr_new(ctx, v389);

17190

                            let v391 = &C::gpr_to_gpr_mem_imm(ctx, v387);

17191

                            let v392 = &constructor_x64_sbb_paired(ctx, I64, v390, v391);

17192

                            let v393 = constructor_with_flags(ctx, v388, v392);

17193

                            let v394 = C::output(ctx, v393);

17194

                            // Rule at src/isa/x64/lower.isle line 931.

17195

                            return Some(v394);

17196

17197

17198

17199

                &Opcode::Iabs => {

17200

                    let v1 = C::first_result(ctx, arg0);

17201

                    if let Some(v2) = v1 {

17202

                        let v3 = C::value_type(ctx, v2);

17203

                        match v3 {

17204

                            I8X16 => {

17205

                                let v525 = C::use_ssse3(ctx);

17206

                                if v525 == true {

17207

                                    let v526 = &C::put_in_xmm_mem(ctx, v381);

17208

                                    let v527 = constructor_x64_pabsb(ctx, v526);

17209

                                    let v528 = constructor_output_xmm(ctx, v527);

17210

                                    // Rule at src/isa/x64/lower.isle line 1185.

17211

                                    return Some(v528);

17212

17213

                                let v529 = constructor_put_in_xmm(ctx, v381);

17214

                                let v530 = constructor_xmm_zero(ctx, I8X16);

17215

                                let v531 = &C::xmm_to_xmm_mem(ctx, v529);

17216

                                let v532 = constructor_x64_psubb(ctx, v530, v531);

17217

                                let v533 = &C::xmm_to_xmm_mem(ctx, v532);

17218

                                let v534 = constructor_x64_pminub(ctx, v529, v533);

17219

                                let v535 = constructor_output_xmm(ctx, v534);

17220

                                // Rule at src/isa/x64/lower.isle line 1192.

17221

                                return Some(v535);

17222

17223

                            I16X8 => {

17224

                                let v525 = C::use_ssse3(ctx);

17225

                                if v525 == true {

17226

                                    let v526 = &C::put_in_xmm_mem(ctx, v381);

17227

                                    let v536 = constructor_x64_pabsw(ctx, v526);

17228

                                    let v537 = constructor_output_xmm(ctx, v536);

17229

                                    // Rule at src/isa/x64/lower.isle line 1199.

17230

                                    return Some(v537);

17231

17232

                                let v529 = constructor_put_in_xmm(ctx, v381);

17233

                                let v538 = constructor_xmm_zero(ctx, I16X8);

17234

                                let v531 = &C::xmm_to_xmm_mem(ctx, v529);

17235

                                let v539 = constructor_x64_psubw(ctx, v538, v531);

17236

                                let v540 = &C::xmm_to_xmm_mem(ctx, v539);

17237

                                let v541 = constructor_x64_pmaxsw(ctx, v529, v540);

17238

                                let v542 = constructor_output_xmm(ctx, v541);

17239

                                // Rule at src/isa/x64/lower.isle line 1203.

17240

                                return Some(v542);

17241

17242

                            I32X4 => {

17243

                                let v525 = C::use_ssse3(ctx);

17244

                                if v525 == true {

17245

                                    let v526 = &C::put_in_xmm_mem(ctx, v381);

17246

                                    let v543 = constructor_x64_pabsd(ctx, v526);

17247

                                    let v544 = constructor_output_xmm(ctx, v543);

17248

                                    // Rule at src/isa/x64/lower.isle line 1210.

17249

                                    return Some(v544);

17250

17251

                                let v529 = constructor_put_in_xmm(ctx, v381);

17252

                                let v546 = &C::xmi_imm(ctx, 0x1F);

17253

                                let v547 = constructor_x64_psrad(ctx, v529, v546);

17254

                                let v548 = &C::xmm_to_xmm_mem(ctx, v547);

17255

                                let v549 = constructor_x64_pxor(ctx, v529, v548);

17256

                                let v550 = &C::xmm_to_xmm_mem(ctx, v547);

17257

                                let v551 = constructor_x64_psubd(ctx, v549, v550);

17258

                                let v552 = constructor_output_xmm(ctx, v551);

17259

                                // Rule at src/isa/x64/lower.isle line 1220.

17260

                                return Some(v552);

17261

17262

                            I64X2 => {

17263

                                let v332 = C::use_avx512vl(ctx);

17264

                                if v332 == true {

17265

                                    let v333 = C::use_avx512f(ctx);

17266

                                    if v333 == true {

17267

                                        let v526 = &C::put_in_xmm_mem(ctx, v381);

17268

                                        let v553 = constructor_x64_vpabsq(ctx, v526);

17269

                                        let v554 = constructor_output_xmm(ctx, v553);

17270

                                        // Rule at src/isa/x64/lower.isle line 1229.

17271

                                        return Some(v554);

17272

17273

17274

                                let v441 = C::use_sse41(ctx);

17275

                                if v441 == true {

17276

                                    let v529 = constructor_put_in_xmm(ctx, v381);

17277

                                    let v555 = constructor_imm(ctx, I64X2, 0x0);

17278

                                    let v556 = C::xmm_new(ctx, v555);

17279

                                    let v557 = &C::xmm_to_xmm_mem(ctx, v529);

17280

                                    let v558 = constructor_x64_psubq(ctx, v556, v557);

17281

                                    let v559 = &C::xmm_to_xmm_mem(ctx, v529);

17282

                                    let v560 = constructor_x64_blendvpd(ctx, v558, v559, v558);

17283

                                    let v561 = constructor_output_xmm(ctx, v560);

17284

                                    // Rule at src/isa/x64/lower.isle line 1238.

17285

                                    return Some(v561);

17286

17287

                                let v529 = constructor_put_in_xmm(ctx, v381);

17288

                                let v562 = RegMemImm::Imm { simm32: 0x1F };

17289

                                let v563 = &C::xmm_mem_imm_new(ctx, &v562);

17290

                                let v564 = constructor_x64_psrad(ctx, v529, v563);

17291

                                let v565 = &C::xmm_to_xmm_mem(ctx, v564);

17292

                                let v567 = constructor_x64_pshufd(ctx, v565, 0xF5);

17293

                                let v568 = &C::xmm_to_xmm_mem(ctx, v567);

17294

                                let v569 = constructor_x64_pxor(ctx, v529, v568);

17295

                                let v570 = &C::xmm_to_xmm_mem(ctx, v567);

17296

                                let v571 = constructor_x64_psubq(ctx, v569, v570);

17297

                                let v572 = constructor_output_xmm(ctx, v571);

17298

                                // Rule at src/isa/x64/lower.isle line 1247.

17299

                                return Some(v572);

17300

17301

                            _ => {}

17302

17303

                        let v4 = C::fits_in_64(ctx, v3);

17304

                        if let Some(v5) = v4 {

17305

                            let v382 = constructor_put_in_gpr(ctx, v381);

17306

                            let v573 = &constructor_x64_neg_paired(ctx, v5, v382);

17307

                            let v574 = constructor_produces_flags_get_reg(ctx, v573);

17308

                            let v575 = C::gpr_new(ctx, v574);

17309

                            let v577 = &C::gpr_to_gpr_mem(ctx, v382);

17310

                            let v578 = &constructor_cmove(ctx, v5, &CC::S, v577, v575);

17311

                            let v579 = &constructor_produces_flags_ignore(ctx, v573);

17312

                            let v580 = constructor_with_flags_reg(ctx, v579, v578);

17313

                            let v581 = constructor_output_reg(ctx, v580);

17314

                            // Rule at src/isa/x64/lower.isle line 1256.

17315

                            return Some(v581);

17316

17317

17318

17319

                &Opcode::Bnot => {

17320

                    let v1 = C::first_result(ctx, arg0);

17321

                    if let Some(v2) = v1 {

17322

                        let v3 = C::value_type(ctx, v2);

17323

                        if v3 == I128 {

17324

                            let v627 = constructor_i128_not(ctx, v381);

17325

                            let v628 = C::output(ctx, v627);

17326

                            // Rule at src/isa/x64/lower.isle line 1365.

17327

                            return Some(v628);

17328

17329

                        let v64 = C::multi_lane(ctx, v3);

17330

                        if let Some(v65) = v64 {

17331

                            let v529 = constructor_put_in_xmm(ctx, v381);

17332

                            let v592 = constructor_vector_all_ones(ctx);

17333

                            let v629 = &C::xmm_to_xmm_mem(ctx, v592);

17334

                            let v632 = constructor_x64_xor_vector(ctx, v3, v529, v629);

17335

                            let v633 = constructor_output_xmm(ctx, v632);

17336

                            // Rule at src/isa/x64/lower.isle line 1375.

17337

                            return Some(v633);

17338

17339

                        let v152 = C::ty_int_ref_scalar_64(ctx, v3);

17340

                        if let Some(v153) = v152 {

17341

                            let v382 = constructor_put_in_gpr(ctx, v381);

17342

                            let v625 = constructor_x64_not(ctx, v3, v382);

17343

                            let v626 = constructor_output_gpr(ctx, v625);

17344

                            // Rule at src/isa/x64/lower.isle line 1350.

17345

                            return Some(v626);

17346

17347

                        let v162 = C::ty_scalar_float(ctx, v3);

17348

                        if let Some(v163) = v162 {

17349

                            let v529 = constructor_put_in_xmm(ctx, v381);

17350

                            let v592 = constructor_vector_all_ones(ctx);

17351

                            let v629 = &C::xmm_to_xmm_mem(ctx, v592);

17352

                            let v630 = constructor_x64_xor_vector(ctx, v163, v529, v629);

17353

                            let v631 = constructor_output_xmm(ctx, v630);

17354

                            // Rule at src/isa/x64/lower.isle line 1370.

17355

                            return Some(v631);

17356

17357

17358

17359

                &Opcode::Bitrev => {

17360

                    let v1 = C::first_result(ctx, arg0);

17361

                    if let Some(v2) = v1 {

17362

                        let v3 = C::value_type(ctx, v2);

17363

                        match v3 {

17364

                            I8 => {

17365

                                let v382 = constructor_put_in_gpr(ctx, v381);

17366

                                let v1187 = constructor_do_bitrev8(ctx, I32, v382);

17367

                                let v1188 = constructor_output_gpr(ctx, v1187);

17368

                                // Rule at src/isa/x64/lower.isle line 2320.

17369

                                return Some(v1188);

17370

17371

                            I16 => {

17372

                                let v382 = constructor_put_in_gpr(ctx, v381);

17373

                                let v1189 = constructor_do_bitrev16(ctx, I32, v382);

17374

                                let v1190 = constructor_output_gpr(ctx, v1189);

17375

                                // Rule at src/isa/x64/lower.isle line 2323.

17376

                                return Some(v1190);

17377

17378

                            I32 => {

17379

                                let v382 = constructor_put_in_gpr(ctx, v381);

17380

                                let v1191 = constructor_do_bitrev32(ctx, I32, v382);

17381

                                let v1192 = constructor_output_gpr(ctx, v1191);

17382

                                // Rule at src/isa/x64/lower.isle line 2326.

17383

                                return Some(v1192);

17384

17385

                            I64 => {

17386

                                let v382 = constructor_put_in_gpr(ctx, v381);

17387

                                let v1193 = constructor_do_bitrev64(ctx, I64, v382);

17388

                                let v1194 = constructor_output_gpr(ctx, v1193);

17389

                                // Rule at src/isa/x64/lower.isle line 2329.

17390

                                return Some(v1194);

17391

17392

                            I128 => {

17393

                                let v385 = C::put_in_regs(ctx, v381);

17394

                                let v1077 = constructor_value_regs_get_gpr(ctx, v385, 0x1);

17395

                                let v1195 = constructor_do_bitrev64(ctx, I64, v1077);

17396

                                let v1196 = C::gpr_to_reg(ctx, v1195);

17397

                                let v1197 = C::put_in_regs(ctx, v381);

17398

                                let v1198 = constructor_value_regs_get_gpr(ctx, v1197, 0x0);

17399

                                let v1199 = constructor_do_bitrev64(ctx, I64, v1198);

17400

                                let v1200 = C::gpr_to_reg(ctx, v1199);

17401

                                let v1201 = C::value_regs(ctx, v1196, v1200);

17402

                                let v1202 = C::output(ctx, v1201);

17403

                                // Rule at src/isa/x64/lower.isle line 2332.

17404

                                return Some(v1202);

17405

17406

                            _ => {}

17407

17408

17409

17410

                &Opcode::Clz => {

17411

                    let v1 = C::first_result(ctx, arg0);

17412

                    if let Some(v2) = v1 {

17413

                        let v3 = C::value_type(ctx, v2);

17414

                        let v45 = C::ty_32_or_64(ctx, v3);

17415

                        if let Some(v46) = v45 {

17416

                            let v1067 = C::use_lzcnt(ctx);

17417

                            if v1067 == true {

17418

                                let v382 = constructor_put_in_gpr(ctx, v381);

17419

                                let v1068 = constructor_x64_lzcnt(ctx, v46, v382);

17420

                                let v1069 = constructor_output_gpr(ctx, v1068);

17421

                                // Rule at src/isa/x64/lower.isle line 2099.

17422

                                return Some(v1069);

17423

17424

                            let v382 = constructor_put_in_gpr(ctx, v381);

17425

                            let v1070 = constructor_do_clz(ctx, v46, v46, v382);

17426

                            let v1071 = constructor_output_gpr(ctx, v1070);

17427

                            // Rule at src/isa/x64/lower.isle line 2103.

17428

                            return Some(v1071);

17429

17430

                        let v1072 = C::ty_8_or_16(ctx, v3);

17431

                        if let Some(v1073) = v1072 {

17432

                            let v1074 =

17433

                                constructor_extend_to_gpr(ctx, v381, I32, &ExtendKind::Zero);

17434

                            let v1075 = constructor_do_clz(ctx, I32, v1073, v1074);

17435

                            let v1076 = constructor_output_gpr(ctx, v1075);

17436

                            // Rule at src/isa/x64/lower.isle line 2106.

17437

                            return Some(v1076);

17438

17439

                        if v3 == I128 {

17440

                            let v385 = C::put_in_regs(ctx, v381);

17441

                            let v1077 = constructor_value_regs_get_gpr(ctx, v385, 0x1);

17442

                            let v1078 = constructor_do_clz(ctx, I64, I64, v1077);

17443

                            let v1079 = C::put_in_regs(ctx, v381);

17444

                            let v1080 = constructor_value_regs_get_gpr(ctx, v1079, 0x0);

17445

                            let v1081 = constructor_do_clz(ctx, I64, I64, v1080);

17446

                            let v1083 = RegMemImm::Imm { simm32: 0x40 };

17447

                            let v1084 = &C::gpr_mem_imm_new(ctx, &v1083);

17448

                            let v1085 = constructor_x64_add(ctx, I64, v1081, v1084);

17449

                            let v1087 =

17450

                                &constructor_x64_cmp_imm(ctx, &OperandSize::Size64, 0x40, v1078);

17451

                            let v1088 = &C::gpr_to_gpr_mem(ctx, v1078);

17452

                            let v1089 = &constructor_cmove(ctx, I64, &CC::NZ, v1088, v1085);

17453

                            let v1090 = constructor_with_flags_reg(ctx, v1087, v1089);

17454

                            let v1091 = C::gpr_new(ctx, v1090);

17455

                            let v1092 = C::gpr_to_reg(ctx, v1091);

17456

                            let v1093 = constructor_imm(ctx, I64, 0x0);

17457

                            let v1094 = C::value_regs(ctx, v1092, v1093);

17458

                            let v1095 = C::output(ctx, v1094);

17459

                            // Rule at src/isa/x64/lower.isle line 2111.

17460

                            return Some(v1095);

17461

17462

17463

17464

                &Opcode::Ctz => {

17465

                    let v1 = C::first_result(ctx, arg0);

17466

                    if let Some(v2) = v1 {

17467

                        let v3 = C::value_type(ctx, v2);

17468

                        let v45 = C::ty_32_or_64(ctx, v3);

17469

                        if let Some(v46) = v45 {

17470

                            let v188 = C::use_bmi1(ctx);

17471

                            if v188 == true {

17472

                                let v382 = constructor_put_in_gpr(ctx, v381);

17473

                                let v1096 = constructor_x64_tzcnt(ctx, v46, v382);

17474

                                let v1097 = constructor_output_gpr(ctx, v1096);

17475

                                // Rule at src/isa/x64/lower.isle line 2136.

17476

                                return Some(v1097);

17477

17478

                            let v382 = constructor_put_in_gpr(ctx, v381);

17479

                            let v1098 = constructor_do_ctz(ctx, v46, v46, v382);

17480

                            let v1099 = constructor_output_gpr(ctx, v1098);

17481

                            // Rule at src/isa/x64/lower.isle line 2140.

17482

                            return Some(v1099);

17483

17484

                        let v1072 = C::ty_8_or_16(ctx, v3);

17485

                        if let Some(v1073) = v1072 {

17486

                            let v1074 =

17487

                                constructor_extend_to_gpr(ctx, v381, I32, &ExtendKind::Zero);

17488

                            let v1100 = constructor_do_ctz(ctx, I32, v1073, v1074);

17489

                            let v1101 = constructor_output_gpr(ctx, v1100);

17490

                            // Rule at src/isa/x64/lower.isle line 2143.

17491

                            return Some(v1101);

17492

17493

                        if v3 == I128 {

17494

                            let v385 = C::put_in_regs(ctx, v381);

17495

                            let v386 = constructor_value_regs_get_gpr(ctx, v385, 0x0);

17496

                            let v1102 = constructor_do_ctz(ctx, I64, I64, v386);

17497

                            let v1079 = C::put_in_regs(ctx, v381);

17498

                            let v1103 = constructor_value_regs_get_gpr(ctx, v1079, 0x1);

17499

                            let v1104 = constructor_do_ctz(ctx, I64, I64, v1103);

17500

                            let v1083 = RegMemImm::Imm { simm32: 0x40 };

17501

                            let v1084 = &C::gpr_mem_imm_new(ctx, &v1083);

17502

                            let v1105 = constructor_x64_add(ctx, I64, v1104, v1084);

17503

                            let v1106 =

17504

                                &constructor_x64_cmp_imm(ctx, &OperandSize::Size64, 0x40, v1102);

17505

                            let v1107 = &C::gpr_to_gpr_mem(ctx, v1105);

17506

                            let v1108 = &constructor_cmove(ctx, I64, &CC::Z, v1107, v1102);

17507

                            let v1109 = constructor_with_flags_reg(ctx, v1106, v1108);

17508

                            let v1110 = C::gpr_new(ctx, v1109);

17509

                            let v1111 = C::gpr_to_reg(ctx, v1110);

17510

                            let v1093 = constructor_imm(ctx, I64, 0x0);

17511

                            let v1112 = C::value_regs(ctx, v1111, v1093);

17512

                            let v1113 = C::output(ctx, v1112);

17513

                            // Rule at src/isa/x64/lower.isle line 2148.

17514

                            return Some(v1113);

17515

17516

17517

17518

                &Opcode::Bswap => {

17519

                    let v1 = C::first_result(ctx, arg0);

17520

                    if let Some(v2) = v1 {

17521

                        let v3 = C::value_type(ctx, v2);

17522

                        match v3 {

17523

                            I16 => {

17524

                                let v382 = constructor_put_in_gpr(ctx, v381);

17525

                                let v1204 = Imm8Reg::Imm8 { imm: 0x8 };

17526

                                let v1205 = &C::imm8_reg_to_imm8_gpr(ctx, &v1204);

17527

                                let v1206 = constructor_x64_rotl(ctx, I16, v382, v1205);

17528

                                let v1207 = constructor_output_gpr(ctx, v1206);

17529

                                // Rule at src/isa/x64/lower.isle line 2399.

17530

                                return Some(v1207);

17531

17532

                            I32 => {

17533

                                let v382 = constructor_put_in_gpr(ctx, v381);

17534

                                let v1208 = constructor_x64_bswap(ctx, I32, v382);

17535

                                let v1209 = constructor_output_gpr(ctx, v1208);

17536

                                // Rule at src/isa/x64/lower.isle line 2402.

17537

                                return Some(v1209);

17538

17539

                            I64 => {

17540

                                let v382 = constructor_put_in_gpr(ctx, v381);

17541

                                let v1210 = constructor_x64_bswap(ctx, I64, v382);

17542

                                let v1211 = constructor_output_gpr(ctx, v1210);

17543

                                // Rule at src/isa/x64/lower.isle line 2405.

17544

                                return Some(v1211);

17545

17546

                            I128 => {

17547

                                let v385 = C::put_in_regs(ctx, v381);

17548

                                let v1077 = constructor_value_regs_get_gpr(ctx, v385, 0x1);

17549

                                let v1212 = constructor_x64_bswap(ctx, I64, v1077);

17550

                                let v1213 = C::gpr_to_reg(ctx, v1212);

17551

                                let v1197 = C::put_in_regs(ctx, v381);

17552

                                let v1198 = constructor_value_regs_get_gpr(ctx, v1197, 0x0);

17553

                                let v1214 = constructor_x64_bswap(ctx, I64, v1198);

17554

                                let v1215 = C::gpr_to_reg(ctx, v1214);

17555

                                let v1216 = C::value_regs(ctx, v1213, v1215);

17556

                                let v1217 = C::output(ctx, v1216);

17557

                                // Rule at src/isa/x64/lower.isle line 2408.

17558

                                return Some(v1217);

17559

17560

                            _ => {}

17561

17562

17563

17564

                &Opcode::Popcnt => {

17565

                    let v1 = C::first_result(ctx, arg0);

17566

                    if let Some(v2) = v1 {

17567

                        let v1114 = C::use_popcnt(ctx);

17568

                        if v1114 == true {

17569

                            let v3 = C::value_type(ctx, v2);

17570

                            let v45 = C::ty_32_or_64(ctx, v3);

17571

                            if let Some(v46) = v45 {

17572

                                let v382 = constructor_put_in_gpr(ctx, v381);

17573

                                let v1115 = constructor_x64_popcnt(ctx, v46, v382);

17574

                                let v1116 = constructor_output_gpr(ctx, v1115);

17575

                                // Rule at src/isa/x64/lower.isle line 2167.

17576

                                return Some(v1116);

17577

17578

                            let v1072 = C::ty_8_or_16(ctx, v3);

17579

                            if let Some(v1073) = v1072 {

17580

                                let v1074 =

17581

                                    constructor_extend_to_gpr(ctx, v381, I32, &ExtendKind::Zero);

17582

                                let v1117 = constructor_x64_popcnt(ctx, I32, v1074);

17583

                                let v1118 = constructor_output_gpr(ctx, v1117);

17584

                                // Rule at src/isa/x64/lower.isle line 2171.

17585

                                return Some(v1118);

17586

17587

17588

                        let v3 = C::value_type(ctx, v2);

17589

                        match v3 {

17590

                            I128 => {

17591

                                if v1114 == true {

17592

                                    let v385 = C::put_in_regs(ctx, v381);

17593

                                    let v386 = constructor_value_regs_get_gpr(ctx, v385, 0x0);

17594

                                    let v1119 = constructor_x64_popcnt(ctx, I64, v386);

17595

                                    let v1079 = C::put_in_regs(ctx, v381);

17596

                                    let v1103 = constructor_value_regs_get_gpr(ctx, v1079, 0x1);

17597

                                    let v1120 = constructor_x64_popcnt(ctx, I64, v1103);

17598

                                    let v1121 = &C::gpr_to_gpr_mem_imm(ctx, v1120);

17599

                                    let v1122 = constructor_x64_add(ctx, I64, v1119, v1121);

17600

                                    let v1123 = C::gpr_to_reg(ctx, v1122);

17601

                                    let v1124 = constructor_imm(ctx, I64, 0x0);

17602

                                    let v1125 = C::value_regs(ctx, v1123, v1124);

17603

                                    let v1126 = C::output(ctx, v1125);

17604

                                    // Rule at src/isa/x64/lower.isle line 2175.

17605

                                    return Some(v1126);

17606

17607

                                let v385 = C::put_in_regs(ctx, v381);

17608

                                let v386 = constructor_value_regs_get_gpr(ctx, v385, 0x0);

17609

                                let v1131 = constructor_do_popcnt(ctx, I64, v386);

17610

                                let v1079 = C::put_in_regs(ctx, v381);

17611

                                let v1103 = constructor_value_regs_get_gpr(ctx, v1079, 0x1);

17612

                                let v1132 = constructor_do_popcnt(ctx, I64, v1103);

17613

                                let v1133 = &C::gpr_to_gpr_mem_imm(ctx, v1132);

17614

                                let v1134 = constructor_x64_add(ctx, I64, v1131, v1133);

17615

                                let v1135 = C::gpr_to_reg(ctx, v1134);

17616

                                let v1124 = constructor_imm(ctx, I64, 0x0);

17617

                                let v1136 = C::value_regs(ctx, v1135, v1124);

17618

                                let v1137 = C::output(ctx, v1136);

17619

                                // Rule at src/isa/x64/lower.isle line 2191.

17620

                                return Some(v1137);

17621

17622

                            I8X16 => {

17623

                                let v332 = C::use_avx512vl(ctx);

17624

                                if v332 == true {

17625

                                    let v1138 = C::use_avx512bitalg(ctx);

17626

                                    if v1138 == true {

17627

                                        let v526 = &C::put_in_xmm_mem(ctx, v381);

17628

                                        let v1139 = constructor_x64_vpopcntb(ctx, v526);

17629

                                        let v1140 = constructor_output_xmm(ctx, v1139);

17630

                                        // Rule at src/isa/x64/lower.isle line 2264.

17631

                                        return Some(v1140);

17632

17633

17634

                                let v525 = C::use_ssse3(ctx);

17635

                                if v525 == true {

17636

                                    let v1142 = C::emit_u128_le_const(

17637

                                        ctx,

17638

                                        0xF0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F,

17639

);

17640

                                    let v1143 = &constructor_const_to_xmm_mem(ctx, v1142);

17641

                                    let v1144 = constructor_put_in_xmm(ctx, v381);

17642

                                    let v1145 = constructor_sse_and(ctx, I8X16, v1144, v1143);

17643

                                    let v1146 = constructor_put_in_xmm(ctx, v381);

17644

                                    let v1148 = &C::xmi_imm(ctx, 0x4);

17645

                                    let v1149 = constructor_x64_psrlw(ctx, v1146, v1148);

17646

                                    let v1150 = constructor_sse_and(ctx, I8X16, v1149, v1143);

17647

                                    let v1152 = C::emit_u128_le_const(

17648

                                        ctx,

17649

                                        0x4030302030202010302020102010100,

17650

);

17651

                                    let v1153 = constructor_x64_xmm_load_const(ctx, I8X16, v1152);

17652

                                    let v1154 = &C::xmm_to_xmm_mem(ctx, v1145);

17653

                                    let v1155 = constructor_x64_pshufb(ctx, v1153, v1154);

17654

                                    let v1156 = &C::xmm_to_xmm_mem(ctx, v1150);

17655

                                    let v1157 = constructor_x64_pshufb(ctx, v1153, v1156);

17656

                                    let v1158 = &C::xmm_to_xmm_mem(ctx, v1157);

17657

                                    let v1159 = constructor_x64_paddb(ctx, v1155, v1158);

17658

                                    let v1160 = constructor_output_xmm(ctx, v1159);

17659

                                    // Rule at src/isa/x64/lower.isle line 2290.

17660

                                    return Some(v1160);

17661

17662

                                let v1162 =

17663

                                    C::emit_u128_le_const(ctx, 0x77777777777777777777777777777777);

17664

                                let v1163 = &constructor_const_to_xmm_mem(ctx, v1162);

17665

                                let v1144 = constructor_put_in_xmm(ctx, v381);

17666

                                let v1164 = &C::xmi_imm(ctx, 0x1);

17667

                                let v1165 = constructor_x64_psrlq(ctx, v1144, v1164);

17668

                                let v1166 = constructor_x64_pand(ctx, v1165, v1163);

17669

                                let v1167 = &C::xmm_to_xmm_mem(ctx, v1166);

17670

                                let v1168 = constructor_x64_psubb(ctx, v1144, v1167);

17671

                                let v1169 = &C::xmi_imm(ctx, 0x1);

17672

                                let v1170 = constructor_x64_psrlq(ctx, v1166, v1169);

17673

                                let v1171 = constructor_x64_pand(ctx, v1170, v1163);

17674

                                let v1172 = &C::xmm_to_xmm_mem(ctx, v1171);

17675

                                let v1173 = constructor_x64_psubb(ctx, v1168, v1172);

17676

                                let v1174 = &C::xmi_imm(ctx, 0x1);

17677

                                let v1175 = constructor_x64_psrlq(ctx, v1171, v1174);

17678

                                let v1176 = constructor_x64_pand(ctx, v1175, v1163);

17679

                                let v1177 = &C::xmm_to_xmm_mem(ctx, v1176);

17680

                                let v1178 = constructor_x64_psubb(ctx, v1173, v1177);

17681

                                let v1179 = &C::xmi_imm(ctx, 0x4);

17682

                                let v1180 = constructor_x64_psrlw(ctx, v1178, v1179);

17683

                                let v1181 = &C::xmm_to_xmm_mem(ctx, v1180);

17684

                                let v1182 = constructor_x64_paddb(ctx, v1178, v1181);

17685

                                let v1183 =

17686

                                    C::emit_u128_le_const(ctx, 0xF0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F);

17687

                                let v1184 = &constructor_const_to_xmm_mem(ctx, v1183);

17688

                                let v1185 = constructor_x64_pand(ctx, v1182, v1184);

17689

                                let v1186 = constructor_output_xmm(ctx, v1185);

17690

                                // Rule at src/isa/x64/lower.isle line 2306.

17691

                                return Some(v1186);

17692

17693

                            _ => {}

17694

17695

                        let v45 = C::ty_32_or_64(ctx, v3);

17696

                        if let Some(v46) = v45 {

17697

                            let v382 = constructor_put_in_gpr(ctx, v381);

17698

                            let v1127 = constructor_do_popcnt(ctx, v46, v382);

17699

                            let v1128 = constructor_output_gpr(ctx, v1127);

17700

                            // Rule at src/isa/x64/lower.isle line 2181.

17701

                            return Some(v1128);

17702

17703

                        let v1072 = C::ty_8_or_16(ctx, v3);

17704

                        if let Some(v1073) = v1072 {

17705

                            let v1074 =

17706

                                constructor_extend_to_gpr(ctx, v381, I32, &ExtendKind::Zero);

17707

                            let v1129 = constructor_do_popcnt(ctx, I32, v1074);

17708

                            let v1130 = constructor_output_gpr(ctx, v1129);

17709

                            // Rule at src/isa/x64/lower.isle line 2186.

17710

                            return Some(v1130);

17711

17712

17713

17714

                &Opcode::Sqrt => {

17715

                    let v1 = C::first_result(ctx, arg0);

17716

                    if let Some(v2) = v1 {

17717

                        let v3 = C::value_type(ctx, v2);

17718

                        match v3 {

17719

                            F32 => {

17720

                                let v526 = &C::put_in_xmm_mem(ctx, v381);

17721

                                let v1301 = constructor_x64_sqrtss(ctx, v526);

17722

                                let v1302 = constructor_output_xmm(ctx, v1301);

17723

                                // Rule at src/isa/x64/lower.isle line 2555.

17724

                                return Some(v1302);

17725

17726

                            F64 => {

17727

                                let v526 = &C::put_in_xmm_mem(ctx, v381);

17728

                                let v1303 = constructor_x64_sqrtsd(ctx, v526);

17729

                                let v1304 = constructor_output_xmm(ctx, v1303);

17730

                                // Rule at src/isa/x64/lower.isle line 2557.

17731

                                return Some(v1304);

17732

17733

                            F32X4 => {

17734

                                let v526 = &C::put_in_xmm_mem(ctx, v381);

17735

                                let v1305 = constructor_x64_sqrtps(ctx, v526);

17736

                                let v1306 = constructor_output_xmm(ctx, v1305);

17737

                                // Rule at src/isa/x64/lower.isle line 2559.

17738

                                return Some(v1306);

17739

17740

                            F64X2 => {

17741

                                let v526 = &C::put_in_xmm_mem(ctx, v381);

17742

                                let v1307 = constructor_x64_sqrtpd(ctx, v526);

17743

                                let v1308 = constructor_output_xmm(ctx, v1307);

17744

                                // Rule at src/isa/x64/lower.isle line 2561.

17745

                                return Some(v1308);

17746

17747

                            _ => {}

17748

17749

17750

17751

                &Opcode::Fneg => {

17752

                    let v1 = C::first_result(ctx, arg0);

17753

                    if let Some(v2) = v1 {

17754

                        let v3 = C::value_type(ctx, v2);

17755

                        match v3 {

17756

                            F32 => {

17757

                                let v529 = constructor_put_in_xmm(ctx, v381);

17758

                                let v603 = constructor_imm(ctx, F32, 0x80000000);

17759

                                let v604 = &constructor_reg_to_xmm_mem(ctx, v603);

17760

                                let v605 = constructor_x64_xorps(ctx, v529, v604);

17761

                                let v606 = constructor_output_xmm(ctx, v605);

17762

                                // Rule at src/isa/x64/lower.isle line 1288.

17763

                                return Some(v606);

17764

17765

                            F64 => {

17766

                                let v529 = constructor_put_in_xmm(ctx, v381);

17767

                                let v608 = constructor_imm(ctx, F64, 0x8000000000000000);

17768

                                let v609 = &constructor_reg_to_xmm_mem(ctx, v608);

17769

                                let v610 = constructor_x64_xorpd(ctx, v529, v609);

17770

                                let v611 = constructor_output_xmm(ctx, v610);

17771

                                // Rule at src/isa/x64/lower.isle line 1291.

17772

                                return Some(v611);

17773

17774

                            F32X4 => {

17775

                                let v529 = constructor_put_in_xmm(ctx, v381);

17776

                                let v592 = constructor_vector_all_ones(ctx);

17777

                                let v612 = &C::xmi_imm(ctx, 0x1F);

17778

                                let v613 = constructor_x64_pslld(ctx, v592, v612);

17779

                                let v614 = &C::xmm_to_xmm_mem(ctx, v613);

17780

                                let v615 = constructor_x64_xorps(ctx, v529, v614);

17781

                                let v616 = constructor_output_xmm(ctx, v615);

17782

                                // Rule at src/isa/x64/lower.isle line 1294.

17783

                                return Some(v616);

17784

17785

                            F64X2 => {

17786

                                let v529 = constructor_put_in_xmm(ctx, v381);

17787

                                let v592 = constructor_vector_all_ones(ctx);

17788

                                let v617 = &C::xmi_imm(ctx, 0x3F);

17789

                                let v618 = constructor_x64_psllq(ctx, v592, v617);

17790

                                let v619 = &C::xmm_to_xmm_mem(ctx, v618);

17791

                                let v620 = constructor_x64_xorpd(ctx, v529, v619);

17792

                                let v621 = constructor_output_xmm(ctx, v620);

17793

                                // Rule at src/isa/x64/lower.isle line 1298.

17794

                                return Some(v621);

17795

17796

                            _ => {}

17797

17798

17799

17800

                &Opcode::Fabs => {

17801

                    let v1 = C::first_result(ctx, arg0);

17802

                    if let Some(v2) = v1 {

17803

                        let v3 = C::value_type(ctx, v2);

17804

                        match v3 {

17805

                            F32 => {

17806

                                let v529 = constructor_put_in_xmm(ctx, v381);

17807

                                let v583 = constructor_imm(ctx, F32, 0x7FFFFFFF);

17808

                                let v584 = &constructor_reg_to_xmm_mem(ctx, v583);

17809

                                let v585 = constructor_x64_andps(ctx, v529, v584);

17810

                                let v586 = constructor_output_xmm(ctx, v585);

17811

                                // Rule at src/isa/x64/lower.isle line 1270.

17812

                                return Some(v586);

17813

17814

                            F64 => {

17815

                                let v529 = constructor_put_in_xmm(ctx, v381);

17816

                                let v588 = constructor_imm(ctx, F64, 0x7FFFFFFFFFFFFFFF);

17817

                                let v589 = &constructor_reg_to_xmm_mem(ctx, v588);

17818

                                let v590 = constructor_x64_andpd(ctx, v529, v589);

17819

                                let v591 = constructor_output_xmm(ctx, v590);

17820

                                // Rule at src/isa/x64/lower.isle line 1273.

17821

                                return Some(v591);

17822

17823

                            F32X4 => {

17824

                                let v529 = constructor_put_in_xmm(ctx, v381);

17825

                                let v592 = constructor_vector_all_ones(ctx);

17826

                                let v593 = &C::xmi_imm(ctx, 0x1);

17827

                                let v594 = constructor_x64_psrld(ctx, v592, v593);

17828

                                let v595 = &C::xmm_to_xmm_mem(ctx, v594);

17829

                                let v596 = constructor_x64_andps(ctx, v529, v595);

17830

                                let v597 = constructor_output_xmm(ctx, v596);

17831

                                // Rule at src/isa/x64/lower.isle line 1277.

17832

                                return Some(v597);

17833

17834

                            F64X2 => {

17835

                                let v529 = constructor_put_in_xmm(ctx, v381);

17836

                                let v592 = constructor_vector_all_ones(ctx);

17837

                                let v593 = &C::xmi_imm(ctx, 0x1);

17838

                                let v598 = constructor_x64_psrlq(ctx, v592, v593);

17839

                                let v599 = &C::xmm_to_xmm_mem(ctx, v598);

17840

                                let v600 = constructor_x64_andpd(ctx, v529, v599);

17841

                                let v601 = constructor_output_xmm(ctx, v600);

17842

                                // Rule at src/isa/x64/lower.isle line 1282.

17843

                                return Some(v601);

17844

17845

                            _ => {}

17846

17847

17848

17849

                &Opcode::Ceil => {

17850

                    let v2146 = &C::put_in_reg_mem(ctx, v381);

17851

                    let v622 = C::value_type(ctx, v381);

17852

                    let v2148 = constructor_x64_round(ctx, v622, v2146, &RoundImm::RoundUp);

17853

                    let v2149 = constructor_output_xmm(ctx, v2148);

17854

                    // Rule at src/isa/x64/lower.isle line 3983.

17855

                    return Some(v2149);

17856

17857

                &Opcode::Floor => {

17858

                    let v2146 = &C::put_in_reg_mem(ctx, v381);

17859

                    let v622 = C::value_type(ctx, v381);

17860

                    let v2151 = constructor_x64_round(ctx, v622, v2146, &RoundImm::RoundDown);

17861

                    let v2152 = constructor_output_xmm(ctx, v2151);

17862

                    // Rule at src/isa/x64/lower.isle line 3988.

17863

                    return Some(v2152);

17864

17865

                &Opcode::Trunc => {

17866

                    let v2146 = &C::put_in_reg_mem(ctx, v381);

17867

                    let v622 = C::value_type(ctx, v381);

17868

                    let v2157 = constructor_x64_round(ctx, v622, v2146, &RoundImm::RoundZero);

17869

                    let v2158 = constructor_output_xmm(ctx, v2157);

17870

                    // Rule at src/isa/x64/lower.isle line 3998.

17871

                    return Some(v2158);

17872

17873

                &Opcode::Nearest => {

17874

                    let v2146 = &C::put_in_reg_mem(ctx, v381);

17875

                    let v622 = C::value_type(ctx, v381);

17876

                    let v2154 = constructor_x64_round(ctx, v622, v2146, &RoundImm::RoundNearest);

17877

                    let v2155 = constructor_output_xmm(ctx, v2154);

17878

                    // Rule at src/isa/x64/lower.isle line 3993.

17879

                    return Some(v2155);

17880

17881

                &Opcode::IsNull => {

17882

                    let v622 = C::value_type(ctx, v381);

17883

                    if v622 == R64 {

17884

                        let v382 = constructor_put_in_gpr(ctx, v381);

17885

                        let v1219 = &constructor_x64_cmp_imm(ctx, &OperandSize::Size64, 0x0, v382);

17886

                        let v1220 = &constructor_x64_setcc(ctx, &CC::Z);

17887

                        let v1221 = constructor_with_flags(ctx, v1219, v1220);

17888

                        let v1222 = C::output(ctx, v1221);

17889

                        // Rule at src/isa/x64/lower.isle line 2416.

17890

                        return Some(v1222);

17891

17892

17893

                &Opcode::IsInvalid => {

17894

                    let v622 = C::value_type(ctx, v381);

17895

                    if v622 == R64 {

17896

                        let v382 = constructor_put_in_gpr(ctx, v381);

17897

                        let v1224 =

17898

                            &constructor_x64_cmp_imm(ctx, &OperandSize::Size64, 0xFFFFFFFF, v382);

17899

                        let v1220 = &constructor_x64_setcc(ctx, &CC::Z);

17900

                        let v1225 = constructor_with_flags(ctx, v1224, v1220);

17901

                        let v1226 = C::output(ctx, v1225);

17902

                        // Rule at src/isa/x64/lower.isle line 2424.

17903

                        return Some(v1226);

17904

17905

17906

                &Opcode::ScalarToVector => {

17907

                    let v2402 = &C::sinkable_load(ctx, v381);

17908

                    if let Some(v2403) = v2402 {

17909

                        let v622 = C::value_type(ctx, v381);

17910

                        let v2409 = C::ty_64(ctx, v622);

17911

                        if let Some(v2410) = v2409 {

17912

                            let v2406 = &C::sink_load(ctx, v2403);

17913

                            let v2411 = constructor_x64_movsd_load(ctx, v2406);

17914

                            let v2412 = constructor_output_xmm(ctx, v2411);

17915

                            // Rule at src/isa/x64/lower.isle line 4440.

17916

                            return Some(v2412);

17917

17918

                        let v2404 = C::ty_32(ctx, v622);

17919

                        if let Some(v2405) = v2404 {

17920

                            let v2406 = &C::sink_load(ctx, v2403);

17921

                            let v2407 = constructor_x64_movss_load(ctx, v2406);

17922

                            let v2408 = constructor_output_xmm(ctx, v2407);

17923

                            // Rule at src/isa/x64/lower.isle line 4438.

17924

                            return Some(v2408);

17925

17926

17927

                    let v622 = C::value_type(ctx, v381);

17928

                    let v1862 = C::ty_scalar_float(ctx, v622);

17929

                    if let Some(v1863) = v1862 {

17930

                        let v1245 = constructor_output_value(ctx, v381);

17931

                        // Rule at src/isa/x64/lower.isle line 4428.

17932

                        return Some(v1245);

17933

17934

                    let v382 = constructor_put_in_gpr(ctx, v381);

17935

                    let v2400 = constructor_bitcast_gpr_to_xmm(ctx, v622, v382);

17936

                    let v2401 = constructor_output_xmm(ctx, v2400);

17937

                    // Rule at src/isa/x64/lower.isle line 4433.

17938

                    return Some(v2401);

17939

17940

                &Opcode::Bmask => {

17941

                    let v1 = C::first_result(ctx, arg0);

17942

                    if let Some(v2) = v1 {

17943

                        let v385 = C::put_in_regs(ctx, v381);

17944

                        let v3 = C::value_type(ctx, v2);

17945

                        let v622 = C::value_type(ctx, v381);

17946

                        let v623 = constructor_lower_bmask(ctx, v3, v622, v385);

17947

                        let v624 = C::output(ctx, v623);

17948

                        // Rule at src/isa/x64/lower.isle line 1343.

17949

                        return Some(v624);

17950

17951

17952

                &Opcode::Ireduce => {

17953

                    let v1 = C::first_result(ctx, arg0);

17954

                    if let Some(v2) = v1 {

17955

                        let v3 = C::value_type(ctx, v2);

17956

                        let v4 = C::fits_in_64(ctx, v3);

17957

                        if let Some(v5) = v4 {

17958

                            let v385 = C::put_in_regs(ctx, v381);

17959

                            let v386 = constructor_value_regs_get_gpr(ctx, v385, 0x0);

17960

                            let v1246 = constructor_output_gpr(ctx, v386);

17961

                            // Rule at src/isa/x64/lower.isle line 2474.

17962

                            return Some(v1246);

17963

17964

                        let v622 = C::value_type(ctx, v381);

17965

                        if v3 == v622 {

17966

                            let v1245 = constructor_output_value(ctx, v381);

17967

                            // Rule at src/isa/x64/lower.isle line 2468.

17968

                            return Some(v1245);

17969

17970

17971

17972

                &Opcode::SwidenLow => {

17973

                    let v1 = C::first_result(ctx, arg0);

17974

                    if let Some(v2) = v1 {

17975

                        let v3 = C::value_type(ctx, v2);

17976

                        match v3 {

17977

                            I16X8 => {

17978

                                let v441 = C::use_sse41(ctx);

17979

                                if v441 == true {

17980

                                    let v622 = C::value_type(ctx, v381);

17981

                                    if v622 == I8X16 {

17982

                                        let v526 = &C::put_in_xmm_mem(ctx, v381);

17983

                                        let v2032 = constructor_x64_pmovsxbw(ctx, v526);

17984

                                        let v2033 = constructor_output_xmm(ctx, v2032);

17985

                                        // Rule at src/isa/x64/lower.isle line 3703.

17986

                                        return Some(v2033);

17987

17988

17989

17990

                            I32X4 => {

17991

                                let v441 = C::use_sse41(ctx);

17992

                                if v441 == true {

17993

                                    let v622 = C::value_type(ctx, v381);

17994

                                    if v622 == I16X8 {

17995

                                        let v526 = &C::put_in_xmm_mem(ctx, v381);

17996

                                        let v2034 = constructor_x64_pmovsxwd(ctx, v526);

17997

                                        let v2035 = constructor_output_xmm(ctx, v2034);

17998

                                        // Rule at src/isa/x64/lower.isle line 3706.

17999

                                        return Some(v2035);

18000

18001

18002

18003

                            I64X2 => {

18004

                                let v441 = C::use_sse41(ctx);

18005

                                if v441 == true {

18006

                                    let v622 = C::value_type(ctx, v381);

18007

                                    if v622 == I32X4 {

18008

                                        let v526 = &C::put_in_xmm_mem(ctx, v381);

18009

                                        let v2036 = constructor_x64_pmovsxdq(ctx, v526);

18010

                                        let v2037 = constructor_output_xmm(ctx, v2036);

18011

                                        // Rule at src/isa/x64/lower.isle line 3709.

18012

                                        return Some(v2037);

18013

18014

18015

18016

                            _ => {}

18017

18018

                        let v529 = constructor_put_in_xmm(ctx, v381);

18019

                        let v2038 = constructor_lower_swiden_low(ctx, v3, v529);

18020

                        let v2039 = constructor_output_xmm(ctx, v2038);

18021

                        // Rule at src/isa/x64/lower.isle line 3713.

18022

                        return Some(v2039);

18023

18024

18025

                &Opcode::SwidenHigh => {

18026

                    let v1 = C::first_result(ctx, arg0);

18027

                    if let Some(v2) = v1 {

18028

                        let v3 = C::value_type(ctx, v2);

18029

                        match v3 {

18030

                            I16X8 => {

18031

                                let v622 = C::value_type(ctx, v381);

18032

                                if v622 == I8X16 {

18033

                                    let v441 = C::use_sse41(ctx);

18034

                                    if v441 == true {

18035

                                        let v525 = C::use_ssse3(ctx);

18036

                                        if v525 == true {

18037

                                            let v529 = constructor_put_in_xmm(ctx, v381);

18038

                                            let v1311 = &C::xmm_to_xmm_mem(ctx, v529);

18039

                                            let v2040 =

18040

                                                constructor_x64_palignr(ctx, v529, v1311, 0x8);

18041

                                            let v2041 = &C::xmm_to_xmm_mem(ctx, v2040);

18042

                                            let v2042 = constructor_x64_pmovsxbw(ctx, v2041);

18043

                                            let v2043 = constructor_output_xmm(ctx, v2042);

18044

                                            // Rule at src/isa/x64/lower.isle line 3736.

18045

                                            return Some(v2043);

18046

18047

18048

                                    let v529 = constructor_put_in_xmm(ctx, v381);

18049

                                    let v1311 = &C::xmm_to_xmm_mem(ctx, v529);

18050

                                    let v2050 = constructor_x64_punpckhbw(ctx, v529, v1311);

18051

                                    let v2051 = &C::xmi_imm(ctx, 0x8);

18052

                                    let v2052 = constructor_x64_psraw(ctx, v2050, v2051);

18053

                                    let v2053 = constructor_output_xmm(ctx, v2052);

18054

                                    // Rule at src/isa/x64/lower.isle line 3752.

18055

                                    return Some(v2053);

18056

18057

18058

                            I32X4 => {

18059

                                let v622 = C::value_type(ctx, v381);

18060

                                if v622 == I16X8 {

18061

                                    let v441 = C::use_sse41(ctx);

18062

                                    if v441 == true {

18063

                                        let v525 = C::use_ssse3(ctx);

18064

                                        if v525 == true {

18065

                                            let v529 = constructor_put_in_xmm(ctx, v381);

18066

                                            let v1311 = &C::xmm_to_xmm_mem(ctx, v529);

18067

                                            let v2040 =

18068

                                                constructor_x64_palignr(ctx, v529, v1311, 0x8);

18069

                                            let v2041 = &C::xmm_to_xmm_mem(ctx, v2040);

18070

                                            let v2044 = constructor_x64_pmovsxwd(ctx, v2041);

18071

                                            let v2045 = constructor_output_xmm(ctx, v2044);

18072

                                            // Rule at src/isa/x64/lower.isle line 3741.

18073

                                            return Some(v2045);

18074

18075

18076

                                    let v529 = constructor_put_in_xmm(ctx, v381);

18077

                                    let v1311 = &C::xmm_to_xmm_mem(ctx, v529);

18078

                                    let v2054 = constructor_x64_punpckhwd(ctx, v529, v1311);

18079

                                    let v1847 = &C::xmi_imm(ctx, 0x10);

18080

                                    let v2055 = constructor_x64_psrad(ctx, v2054, v1847);

18081

                                    let v2056 = constructor_output_xmm(ctx, v2055);

18082

                                    // Rule at src/isa/x64/lower.isle line 3755.

18083

                                    return Some(v2056);

18084

18085

18086

                            I64X2 => {

18087

                                let v622 = C::value_type(ctx, v381);

18088

                                if v622 == I32X4 {

18089

                                    let v441 = C::use_sse41(ctx);

18090

                                    if v441 == true {

18091

                                        let v526 = &C::put_in_xmm_mem(ctx, v381);

18092

                                        let v2046 = constructor_x64_pshufd(ctx, v526, 0xEE);

18093

                                        let v2047 = &C::xmm_to_xmm_mem(ctx, v2046);

18094

                                        let v2048 = constructor_x64_pmovsxdq(ctx, v2047);

18095

                                        let v2049 = constructor_output_xmm(ctx, v2048);

18096

                                        // Rule at src/isa/x64/lower.isle line 3746.

18097

                                        return Some(v2049);

18098

18099

                                    let v526 = &C::put_in_xmm_mem(ctx, v381);

18100

                                    let v2058 = constructor_x64_pshufd(ctx, v526, 0xE);

18101

                                    let v2059 = constructor_xmm_zero(ctx, I32X4);

18102

                                    let v2060 = &C::xmm_to_xmm_mem(ctx, v2058);

18103

                                    let v2061 = constructor_x64_pcmpgtd(ctx, v2059, v2060);

18104

                                    let v2062 = &C::xmm_to_xmm_mem(ctx, v2061);

18105

                                    let v2063 = constructor_x64_punpckldq(ctx, v2058, v2062);

18106

                                    let v2064 = constructor_output_xmm(ctx, v2063);

18107

                                    // Rule at src/isa/x64/lower.isle line 3760.

18108

                                    return Some(v2064);

18109

18110

18111

                            _ => {}

18112

18113

18114

18115

                &Opcode::UwidenLow => {

18116

                    let v1 = C::first_result(ctx, arg0);

18117

                    if let Some(v2) = v1 {

18118

                        let v3 = C::value_type(ctx, v2);

18119

                        match v3 {

18120

                            I16X8 => {

18121

                                let v441 = C::use_sse41(ctx);

18122

                                if v441 == true {

18123

                                    let v622 = C::value_type(ctx, v381);

18124

                                    if v622 == I8X16 {

18125

                                        let v526 = &C::put_in_xmm_mem(ctx, v381);

18126

                                        let v2065 = constructor_x64_pmovzxbw(ctx, v526);

18127

                                        let v2066 = constructor_output_xmm(ctx, v2065);

18128

                                        // Rule at src/isa/x64/lower.isle line 3768.

18129

                                        return Some(v2066);

18130

18131

18132

18133

                            I32X4 => {

18134

                                let v441 = C::use_sse41(ctx);

18135

                                if v441 == true {

18136

                                    let v622 = C::value_type(ctx, v381);

18137

                                    if v622 == I16X8 {

18138

                                        let v526 = &C::put_in_xmm_mem(ctx, v381);

18139

                                        let v2067 = constructor_x64_pmovzxwd(ctx, v526);

18140

                                        let v2068 = constructor_output_xmm(ctx, v2067);

18141

                                        // Rule at src/isa/x64/lower.isle line 3771.

18142

                                        return Some(v2068);

18143

18144

18145

18146

                            I64X2 => {

18147

                                let v441 = C::use_sse41(ctx);

18148

                                if v441 == true {

18149

                                    let v622 = C::value_type(ctx, v381);

18150

                                    if v622 == I32X4 {

18151

                                        let v526 = &C::put_in_xmm_mem(ctx, v381);

18152

                                        let v2069 = constructor_x64_pmovzxdq(ctx, v526);

18153

                                        let v2070 = constructor_output_xmm(ctx, v2069);

18154

                                        // Rule at src/isa/x64/lower.isle line 3774.

18155

                                        return Some(v2070);

18156

18157

18158

18159

                            _ => {}

18160

18161

                        let v529 = constructor_put_in_xmm(ctx, v381);

18162

                        let v2071 = constructor_lower_uwiden_low(ctx, v3, v529);

18163

                        let v2072 = constructor_output_xmm(ctx, v2071);

18164

                        // Rule at src/isa/x64/lower.isle line 3778.

18165

                        return Some(v2072);

18166

18167

18168

                &Opcode::UwidenHigh => {

18169

                    let v1 = C::first_result(ctx, arg0);

18170

                    if let Some(v2) = v1 {

18171

                        let v3 = C::value_type(ctx, v2);

18172

                        match v3 {

18173

                            I16X8 => {

18174

                                let v622 = C::value_type(ctx, v381);

18175

                                if v622 == I8X16 {

18176

                                    let v529 = constructor_put_in_xmm(ctx, v381);

18177

                                    let v530 = constructor_xmm_zero(ctx, I8X16);

18178

                                    let v2073 = &C::xmm_to_xmm_mem(ctx, v530);

18179

                                    let v2074 = constructor_x64_punpckhbw(ctx, v529, v2073);

18180

                                    let v2075 = constructor_output_xmm(ctx, v2074);

18181

                                    // Rule at src/isa/x64/lower.isle line 3793.

18182

                                    return Some(v2075);

18183

18184

18185

                            I32X4 => {

18186

                                let v622 = C::value_type(ctx, v381);

18187

                                if v622 == I16X8 {

18188

                                    let v529 = constructor_put_in_xmm(ctx, v381);

18189

                                    let v530 = constructor_xmm_zero(ctx, I8X16);

18190

                                    let v2073 = &C::xmm_to_xmm_mem(ctx, v530);

18191

                                    let v2076 = constructor_x64_punpckhwd(ctx, v529, v2073);

18192

                                    let v2077 = constructor_output_xmm(ctx, v2076);

18193

                                    // Rule at src/isa/x64/lower.isle line 3795.

18194

                                    return Some(v2077);

18195

18196

18197

                            I64X2 => {

18198

                                let v622 = C::value_type(ctx, v381);

18199

                                if v622 == I32X4 {

18200

                                    let v529 = constructor_put_in_xmm(ctx, v381);

18201

                                    let v1886 = constructor_xmm_zero(ctx, F32X4);

18202

                                    let v1887 = &C::xmm_to_xmm_mem(ctx, v1886);

18203

                                    let v2078 = constructor_x64_unpckhps(ctx, v529, v1887);

18204

                                    let v2079 = constructor_output_xmm(ctx, v2078);

18205

                                    // Rule at src/isa/x64/lower.isle line 3797.

18206

                                    return Some(v2079);

18207

18208

18209

                            _ => {}

18210

18211

18212

18213

                &Opcode::Uextend => {

18214

                    let v1 = C::first_result(ctx, arg0);

18215

                    if let Some(v2) = v1 {

18216

                        let v3 = C::value_type(ctx, v2);

18217

                        match v3 {

18218

                            I64 => {

18219

                                let v1227 =

18220

                                    constructor_extend_to_gpr(ctx, v381, I64, &ExtendKind::Zero);

18221

                                let v1232 = constructor_output_gpr(ctx, v1227);

18222

                                // Rule at src/isa/x64/lower.isle line 2437.

18223

                                return Some(v1232);

18224

18225

                            I128 => {

18226

                                let v1227 =

18227

                                    constructor_extend_to_gpr(ctx, v381, I64, &ExtendKind::Zero);

18228

                                let v1228 = C::gpr_to_reg(ctx, v1227);

18229

                                let v1229 = constructor_imm(ctx, I64, 0x0);

18230

                                let v1230 = C::value_regs(ctx, v1228, v1229);

18231

                                let v1231 = C::output(ctx, v1230);

18232

                                // Rule at src/isa/x64/lower.isle line 2433.

18233

                                return Some(v1231);

18234

18235

                            _ => {}

18236

18237

                        let v1233 = C::fits_in_32(ctx, v3);

18238

                        if let Some(v1234) = v1233 {

18239

                            let v1074 =

18240

                                constructor_extend_to_gpr(ctx, v381, I32, &ExtendKind::Zero);

18241

                            let v1235 = constructor_output_gpr(ctx, v1074);

18242

                            // Rule at src/isa/x64/lower.isle line 2442.

18243

                            return Some(v1235);

18244

18245

18246

18247

                &Opcode::Sextend => {

18248

                    let v1 = C::first_result(ctx, arg0);

18249

                    if let Some(v2) = v1 {

18250

                        let v3 = C::value_type(ctx, v2);

18251

                        match v3 {

18252

                            I64 => {

18253

                                let v1236 =

18254

                                    constructor_extend_to_gpr(ctx, v381, I64, &ExtendKind::Sign);

18255

                                let v1242 = constructor_output_gpr(ctx, v1236);

18256

                                // Rule at src/isa/x64/lower.isle line 2457.

18257

                                return Some(v1242);

18258

18259

                            I128 => {

18260

                                let v1236 =

18261

                                    constructor_extend_to_gpr(ctx, v381, I64, &ExtendKind::Sign);

18262

                                let v840 = Imm8Reg::Imm8 { imm: 0x3F };

18263

                                let v841 = &C::imm8_reg_to_imm8_gpr(ctx, &v840);

18264

                                let v1237 = constructor_x64_sar(ctx, I64, v1236, v841);

18265

                                let v1238 = C::gpr_to_reg(ctx, v1236);

18266

                                let v1239 = C::gpr_to_reg(ctx, v1237);

18267

                                let v1240 = C::value_regs(ctx, v1238, v1239);

18268

                                let v1241 = C::output(ctx, v1240);

18269

                                // Rule at src/isa/x64/lower.isle line 2451.

18270

                                return Some(v1241);

18271

18272

                            _ => {}

18273

18274

                        let v1233 = C::fits_in_32(ctx, v3);

18275

                        if let Some(v1234) = v1233 {

18276

                            let v1243 =

18277

                                constructor_extend_to_gpr(ctx, v381, I32, &ExtendKind::Sign);

18278

                            let v1244 = constructor_output_gpr(ctx, v1243);

18279

                            // Rule at src/isa/x64/lower.isle line 2462.

18280

                            return Some(v1244);

18281

18282

18283

18284

                &Opcode::Fpromote => {

18285

                    let v1 = C::first_result(ctx, arg0);

18286

                    if let Some(v2) = v1 {

18287

                        let v3 = C::value_type(ctx, v2);

18288

                        if v3 == F64 {

18289

                            let v526 = &C::put_in_xmm_mem(ctx, v381);

18290

                            let v1309 = constructor_x64_cvtss2sd(ctx, v526);

18291

                            let v1310 = constructor_output_xmm(ctx, v1309);

18292

                            // Rule at src/isa/x64/lower.isle line 2565.

18293

                            return Some(v1310);

18294

18295

18296

18297

                &Opcode::Fdemote => {

18298

                    let v1 = C::first_result(ctx, arg0);

18299

                    if let Some(v2) = v1 {

18300

                        let v3 = C::value_type(ctx, v2);

18301

                        if v3 == F32 {

18302

                            let v526 = &C::put_in_xmm_mem(ctx, v381);

18303

                            let v1314 = constructor_x64_cvtsd2ss(ctx, v526);

18304

                            let v1315 = constructor_output_xmm(ctx, v1314);

18305

                            // Rule at src/isa/x64/lower.isle line 2573.

18306

                            return Some(v1315);

18307

18308

18309

18310

                &Opcode::Fvdemote => {

18311

                    let v1 = C::first_result(ctx, arg0);

18312

                    if let Some(v2) = v1 {

18313

                        let v3 = C::value_type(ctx, v2);

18314

                        if v3 == F32X4 {

18315

                            let v526 = &C::put_in_xmm_mem(ctx, v381);

18316

                            let v1316 = constructor_x64_cvtpd2ps(ctx, v526);

18317

                            let v1317 = constructor_output_xmm(ctx, v1316);

18318

                            // Rule at src/isa/x64/lower.isle line 2577.

18319

                            return Some(v1317);

18320

18321

18322

18323

                &Opcode::FvpromoteLow => {

18324

                    let v1 = C::first_result(ctx, arg0);

18325

                    if let Some(v2) = v1 {

18326

                        let v3 = C::value_type(ctx, v2);

18327

                        if v3 == F64X2 {

18328

                            let v529 = constructor_put_in_xmm(ctx, v381);

18329

                            let v1311 = &C::xmm_to_xmm_mem(ctx, v529);

18330

                            let v1312 = constructor_x64_cvtps2pd(ctx, v1311);

18331

                            let v1313 = constructor_output_xmm(ctx, v1312);

18332

                            // Rule at src/isa/x64/lower.isle line 2569.

18333

                            return Some(v1313);

18334

18335

18336

18337

                &Opcode::FcvtToUint => {

18338

                    let v1 = C::first_result(ctx, arg0);

18339

                    if let Some(v2) = v1 {

18340

                        let v622 = C::value_type(ctx, v381);

18341

                        let v1862 = C::ty_scalar_float(ctx, v622);

18342

                        if let Some(v1863) = v1862 {

18343

                            let v3 = C::value_type(ctx, v2);

18344

                            let v1864 = constructor_cvt_float_to_uint_seq(ctx, v3, v381, false);

18345

                            let v1865 = constructor_output_gpr(ctx, v1864);

18346

                            // Rule at src/isa/x64/lower.isle line 3455.

18347

                            return Some(v1865);

18348

18349

18350

18351

                &Opcode::FcvtToSint => {

18352

                    let v1 = C::first_result(ctx, arg0);

18353

                    if let Some(v2) = v1 {

18354

                        let v622 = C::value_type(ctx, v381);

18355

                        let v1862 = C::ty_scalar_float(ctx, v622);

18356

                        if let Some(v1863) = v1862 {

18357

                            let v3 = C::value_type(ctx, v2);

18358

                            let v1868 = constructor_cvt_float_to_sint_seq(ctx, v3, v381, false);

18359

                            let v1869 = constructor_output_gpr(ctx, v1868);

18360

                            // Rule at src/isa/x64/lower.isle line 3461.

18361

                            return Some(v1869);

18362

18363

18364

18365

                &Opcode::FcvtToUintSat => {

18366

                    let v1 = C::first_result(ctx, arg0);

18367

                    if let Some(v2) = v1 {

18368

                        let v3 = C::value_type(ctx, v2);

18369

                        if v3 == I32X4 {

18370

                            let v622 = C::value_type(ctx, v381);

18371

                            if v622 == F32X4 {

18372

                                let v529 = constructor_put_in_xmm(ctx, v381);

18373

                                let v1886 = constructor_xmm_zero(ctx, F32X4);

18374

                                let v1887 = &C::xmm_to_xmm_mem(ctx, v1886);

18375

                                let v1888 = constructor_x64_maxps(ctx, v529, v1887);

18376

                                let v1889 = &C::xmm_to_xmm_mem(ctx, v1886);

18377

                                let v1890 = constructor_x64_pcmpeqd(ctx, v1886, v1889);

18378

                                let v1891 = &C::xmi_imm(ctx, 0x1);

18379

                                let v1892 = constructor_x64_psrld(ctx, v1890, v1891);

18380

                                let v1893 = &C::xmm_to_xmm_mem(ctx, v1892);

18381

                                let v1894 = constructor_x64_cvtdq2ps(ctx, v1893);

18382

                                let v1895 = &C::xmm_to_xmm_mem(ctx, v1888);

18383

                                let v1896 = constructor_x64_cvttps2dq(ctx, v1895);

18384

                                let v1897 = &C::xmm_to_xmm_mem(ctx, v1894);

18385

                                let v1898 = constructor_x64_subps(ctx, v1888, v1897);

18386

                                let v1899 = &C::xmm_to_xmm_mem(ctx, v1898);

18387

                                let v1900 = constructor_x64_cmpps(

18388

                                    ctx,

18389

                                    v1894,

18390

                                    v1899,

18391

                                    &FcmpImm::LessThanOrEqual,

18392

);

18393

                                let v1901 = &C::xmm_to_xmm_mem(ctx, v1898);

18394

                                let v1902 = constructor_x64_cvttps2dq(ctx, v1901);

18395

                                let v1903 = &C::xmm_to_xmm_mem(ctx, v1900);

18396

                                let v1904 = constructor_x64_pxor(ctx, v1902, v1903);

18397

                                let v1905 = constructor_xmm_zero(ctx, I32X4);

18398

                                let v1906 = constructor_lower_vec_smax(ctx, I32X4, v1904, v1905);

18399

                                let v1907 = &C::xmm_to_xmm_mem(ctx, v1896);

18400

                                let v1908 = constructor_x64_paddd(ctx, v1906, v1907);

18401

                                let v1909 = constructor_output_xmm(ctx, v1908);

18402

                                // Rule at src/isa/x64/lower.isle line 3539.

18403

                                return Some(v1909);

18404

18405

18406

                        let v622 = C::value_type(ctx, v381);

18407

                        let v1862 = C::ty_scalar_float(ctx, v622);

18408

                        if let Some(v1863) = v1862 {

18409

                            let v1866 = constructor_cvt_float_to_uint_seq(ctx, v3, v381, true);

18410

                            let v1867 = constructor_output_gpr(ctx, v1866);

18411

                            // Rule at src/isa/x64/lower.isle line 3458.

18412

                            return Some(v1867);

18413

18414

18415

18416

                &Opcode::FcvtToSintSat => {

18417

                    let v1 = C::first_result(ctx, arg0);

18418

                    if let Some(v2) = v1 {

18419

                        let v3 = C::value_type(ctx, v2);

18420

                        if v3 == I32X4 {

18421

                            let v622 = C::value_type(ctx, v381);

18422

                            if v622 == F32X4 {

18423

                                let v529 = constructor_put_in_xmm(ctx, v381);

18424

                                let v1311 = &C::xmm_to_xmm_mem(ctx, v529);

18425

                                let v1872 =

18426

                                    constructor_x64_cmpps(ctx, v529, v1311, &FcmpImm::Equal);

18427

                                let v1873 = &C::xmm_to_xmm_mem(ctx, v1872);

18428

                                let v1874 = constructor_x64_andps(ctx, v529, v1873);

18429

                                let v1875 = &C::xmm_to_xmm_mem(ctx, v1874);

18430

                                let v1876 = constructor_x64_pxor(ctx, v1872, v1875);

18431

                                let v1877 = &C::xmm_to_xmm_mem(ctx, v1874);

18432

                                let v1878 = constructor_x64_cvttps2dq(ctx, v1877);

18433

                                let v1879 = &C::xmm_to_xmm_mem(ctx, v1876);

18434

                                let v1880 = constructor_x64_pand(ctx, v1878, v1879);

18435

                                let v1881 = &C::xmi_imm(ctx, 0x1F);

18436

                                let v1882 = constructor_x64_psrad(ctx, v1880, v1881);

18437

                                let v1883 = &C::xmm_to_xmm_mem(ctx, v1878);

18438

                                let v1884 = constructor_x64_pxor(ctx, v1882, v1883);

18439

                                let v1885 = constructor_output_xmm(ctx, v1884);

18440

                                // Rule at src/isa/x64/lower.isle line 3468.

18441

                                return Some(v1885);

18442

18443

18444

                        let v622 = C::value_type(ctx, v381);

18445

                        let v1862 = C::ty_scalar_float(ctx, v622);

18446

                        if let Some(v1863) = v1862 {

18447

                            let v1870 = constructor_cvt_float_to_sint_seq(ctx, v3, v381, true);

18448

                            let v1871 = constructor_output_gpr(ctx, v1870);

18449

                            // Rule at src/isa/x64/lower.isle line 3464.

18450

                            return Some(v1871);

18451

18452

18453

18454

                &Opcode::X86Cvtt2dq => {

18455

                    let v1 = C::first_result(ctx, arg0);

18456

                    if let Some(v2) = v1 {

18457

                        let v3 = C::value_type(ctx, v2);

18458

                        if v3 == I32X4 {

18459

                            let v622 = C::value_type(ctx, v381);

18460

                            if v622 == F32X4 {

18461

                                let v526 = &C::put_in_xmm_mem(ctx, v381);

18462

                                let v1910 = constructor_x64_cvttps2dq(ctx, v526);

18463

                                let v1911 = constructor_output_xmm(ctx, v1910);

18464

                                // Rule at src/isa/x64/lower.isle line 3586.

18465

                                return Some(v1911);

18466

18467

18468

18469

18470

                &Opcode::FcvtFromUint => {

18471

                    let v1 = C::first_result(ctx, arg0);

18472

                    if let Some(v2) = v1 {

18473

                        let v3 = C::value_type(ctx, v2);

18474

                        match v3 {

18475

                            F32 => {

18476

                                let v622 = C::value_type(ctx, v381);

18477

                                let v1820 = C::fits_in_32(ctx, v622);

18478

                                if let Some(v1821) = v1820 {

18479

                                    let v1822 = C::ty_int(ctx, v1821);

18480

                                    if let Some(v1823) = v1822 {

18481

                                        let v1792 = constructor_xmm_zero(ctx, F32X4);

18482

                                        let v1824 = constructor_extend_to_gpr(

18483

                                            ctx,

18484

                                            v381,

18485

                                            I64,

18486

                                            &ExtendKind::Zero,

18487

);

18488

                                        let v1825 = &C::gpr_to_gpr_mem(ctx, v1824);

18489

                                        let v1826 =

18490

                                            constructor_x64_cvtsi2ss(ctx, I64, v1792, v1825);

18491

                                        let v1827 = constructor_output_xmm(ctx, v1826);

18492

                                        // Rule at src/isa/x64/lower.isle line 3382.

18493

                                        return Some(v1827);

18494

18495

18496

18497

                            F64 => {

18498

                                let v622 = C::value_type(ctx, v381);

18499

                                let v1820 = C::fits_in_32(ctx, v622);

18500

                                if let Some(v1821) = v1820 {

18501

                                    let v1822 = C::ty_int(ctx, v1821);

18502

                                    if let Some(v1823) = v1822 {

18503

                                        let v1804 = constructor_xmm_zero(ctx, F64X2);

18504

                                        let v1824 = constructor_extend_to_gpr(

18505

                                            ctx,

18506

                                            v381,

18507

                                            I64,

18508

                                            &ExtendKind::Zero,

18509

);

18510

                                        let v1825 = &C::gpr_to_gpr_mem(ctx, v1824);

18511

                                        let v1828 =

18512

                                            constructor_x64_cvtsi2sd(ctx, I64, v1804, v1825);

18513

                                        let v1829 = constructor_output_xmm(ctx, v1828);

18514

                                        // Rule at src/isa/x64/lower.isle line 3385.

18515

                                        return Some(v1829);

18516

18517

18518

18519

                            F32X4 => {

18520

                                let v332 = C::use_avx512vl(ctx);

18521

                                if v332 == true {

18522

                                    let v333 = C::use_avx512f(ctx);

18523

                                    if v333 == true {

18524

                                        let v526 = &C::put_in_xmm_mem(ctx, v381);

18525

                                        let v1842 = constructor_x64_vcvtudq2ps(ctx, v526);

18526

                                        let v1843 = constructor_output_xmm(ctx, v1842);

18527

                                        // Rule at src/isa/x64/lower.isle line 3403.

18528

                                        return Some(v1843);

18529

18530

18531

                                let v529 = constructor_put_in_xmm(ctx, v381);

18532

                                let v1845 = &C::xmi_imm(ctx, 0x10);

18533

                                let v1846 = constructor_x64_pslld(ctx, v529, v1845);

18534

                                let v1847 = &C::xmi_imm(ctx, 0x10);

18535

                                let v1848 = constructor_x64_psrld(ctx, v1846, v1847);

18536

                                let v1849 = &C::xmm_to_xmm_mem(ctx, v1848);

18537

                                let v1850 = constructor_x64_psubd(ctx, v529, v1849);

18538

                                let v1851 = &C::xmm_to_xmm_mem(ctx, v1848);

18539

                                let v1852 = constructor_x64_cvtdq2ps(ctx, v1851);

18540

                                let v1853 = &C::xmi_imm(ctx, 0x1);

18541

                                let v1854 = constructor_x64_psrld(ctx, v1850, v1853);

18542

                                let v1855 = &C::xmm_to_xmm_mem(ctx, v1854);

18543

                                let v1856 = constructor_x64_cvtdq2ps(ctx, v1855);

18544

                                let v1857 = &C::xmm_to_xmm_mem(ctx, v1856);

18545

                                let v1858 = constructor_x64_addps(ctx, v1856, v1857);

18546

                                let v1859 = &C::xmm_to_xmm_mem(ctx, v1852);

18547

                                let v1860 = constructor_x64_addps(ctx, v1858, v1859);

18548

                                let v1861 = constructor_output_xmm(ctx, v1860);

18549

                                // Rule at src/isa/x64/lower.isle line 3431.

18550

                                return Some(v1861);

18551

18552

                            F64X2 => {

18553

                                let v1811 = C::def_inst(ctx, v381);

18554

                                if let Some(v1812) = v1811 {

18555

                                    let v1813 = &C::inst_data(ctx, v1812);

18556

                                    if let &InstructionData::Unary {

18557

                                        opcode: ref v1814,

18558

                                        arg: v1815,

18559

                                    } = v1813

18560

18561

                                        if let &Opcode::UwidenLow = v1814 {

18562

                                            let v1816 = C::value_type(ctx, v1815);

18563

                                            if v1816 == I32X4 {

18564

                                                let v1833 =

18565

                                                    C::emit_u128_le_const(ctx, 0x4330000043300000);

18566

                                                let v1834 =

18567

                                                    &constructor_const_to_xmm_mem(ctx, v1833);

18568

                                                let v1835 = constructor_put_in_xmm(ctx, v1815);

18569

                                                let v1836 =

18570

                                                    constructor_x64_unpcklps(ctx, v1835, v1834);

18571

                                                let v1838 = C::emit_u128_le_const(

18572

                                                    ctx,

18573

                                                    0x43300000000000004330000000000000,

18574

);

18575

                                                let v1839 =

18576

                                                    &constructor_const_to_xmm_mem(ctx, v1838);

18577

                                                let v1840 =

18578

                                                    constructor_x64_subpd(ctx, v1836, v1839);

18579

                                                let v1841 = constructor_output_xmm(ctx, v1840);

18580

                                                // Rule at src/isa/x64/lower.isle line 3395.

18581

                                                return Some(v1841);

18582

18583

18584

18585

18586

18587

                            _ => {}

18588

18589

                        let v622 = C::value_type(ctx, v381);

18590

                        if v622 == I64 {

18591

                            let v382 = constructor_put_in_gpr(ctx, v381);

18592

                            let v1830 = constructor_cvt_u64_to_float_seq(ctx, v3, v382);

18593

                            let v1831 = constructor_output_xmm(ctx, v1830);

18594

                            // Rule at src/isa/x64/lower.isle line 3388.

18595

                            return Some(v1831);

18596

18597

18598

18599

                &Opcode::FcvtFromSint => {

18600

                    let v1 = C::first_result(ctx, arg0);

18601

                    if let Some(v2) = v1 {

18602

                        let v3 = C::value_type(ctx, v2);

18603

                        match v3 {

18604

                            F32 => {

18605

                                let v622 = C::value_type(ctx, v381);

18606

                                match v622 {

18607

                                    I8 => {

18608

                                        let v1792 = constructor_xmm_zero(ctx, F32X4);

18609

                                        let v1793 = constructor_extend_to_gpr(

18610

                                            ctx,

18611

                                            v381,

18612

                                            I32,

18613

                                            &ExtendKind::Sign,

18614

);

18615

                                        let v1794 = &C::gpr_to_gpr_mem(ctx, v1793);

18616

                                        let v1795 =

18617

                                            constructor_x64_cvtsi2ss(ctx, I32, v1792, v1794);

18618

                                        let v1796 = constructor_output_xmm(ctx, v1795);

18619

                                        // Rule at src/isa/x64/lower.isle line 3356.

18620

                                        return Some(v1796);

18621

18622

                                    I16 => {

18623

                                        let v1792 = constructor_xmm_zero(ctx, F32X4);

18624

                                        let v1793 = constructor_extend_to_gpr(

18625

                                            ctx,

18626

                                            v381,

18627

                                            I32,

18628

                                            &ExtendKind::Sign,

18629

);

18630

                                        let v1794 = &C::gpr_to_gpr_mem(ctx, v1793);

18631

                                        let v1795 =

18632

                                            constructor_x64_cvtsi2ss(ctx, I32, v1792, v1794);

18633

                                        let v1796 = constructor_output_xmm(ctx, v1795);

18634

                                        // Rule at src/isa/x64/lower.isle line 3359.

18635

                                        return Some(v1796);

18636

18637

                                    _ => {}

18638

18639

                                let v1797 = C::ty_int(ctx, v622);

18640

                                if let Some(v1798) = v1797 {

18641

                                    let v1799 = C::fits_in_64(ctx, v1798);

18642

                                    if let Some(v1800) = v1799 {

18643

                                        let v1792 = constructor_xmm_zero(ctx, F32X4);

18644

                                        let v1801 = &constructor_put_in_gpr_mem(ctx, v381);

18645

                                        let v1802 =

18646

                                            constructor_x64_cvtsi2ss(ctx, v1800, v1792, v1801);

18647

                                        let v1803 = constructor_output_xmm(ctx, v1802);

18648

                                        // Rule at src/isa/x64/lower.isle line 3362.

18649

                                        return Some(v1803);

18650

18651

18652

18653

                            F64 => {

18654

                                let v622 = C::value_type(ctx, v381);

18655

                                match v622 {

18656

                                    I8 => {

18657

                                        let v1804 = constructor_xmm_zero(ctx, F64X2);

18658

                                        let v1793 = constructor_extend_to_gpr(

18659

                                            ctx,

18660

                                            v381,

18661

                                            I32,

18662

                                            &ExtendKind::Sign,

18663

);

18664

                                        let v1794 = &C::gpr_to_gpr_mem(ctx, v1793);

18665

                                        let v1805 =

18666

                                            constructor_x64_cvtsi2sd(ctx, I32, v1804, v1794);

18667

                                        let v1806 = constructor_output_xmm(ctx, v1805);

18668

                                        // Rule at src/isa/x64/lower.isle line 3365.

18669

                                        return Some(v1806);

18670

18671

                                    I16 => {

18672

                                        let v1804 = constructor_xmm_zero(ctx, F64X2);

18673

                                        let v1793 = constructor_extend_to_gpr(

18674

                                            ctx,

18675

                                            v381,

18676

                                            I32,

18677

                                            &ExtendKind::Sign,

18678

);

18679

                                        let v1794 = &C::gpr_to_gpr_mem(ctx, v1793);

18680

                                        let v1805 =

18681

                                            constructor_x64_cvtsi2sd(ctx, I32, v1804, v1794);

18682

                                        let v1806 = constructor_output_xmm(ctx, v1805);

18683

                                        // Rule at src/isa/x64/lower.isle line 3368.

18684

                                        return Some(v1806);

18685

18686

                                    _ => {}

18687

18688

                                let v1797 = C::ty_int(ctx, v622);

18689

                                if let Some(v1798) = v1797 {

18690

                                    let v1799 = C::fits_in_64(ctx, v1798);

18691

                                    if let Some(v1800) = v1799 {

18692

                                        let v1804 = constructor_xmm_zero(ctx, F64X2);

18693

                                        let v1801 = &constructor_put_in_gpr_mem(ctx, v381);

18694

                                        let v1807 =

18695

                                            constructor_x64_cvtsi2sd(ctx, v1800, v1804, v1801);

18696

                                        let v1808 = constructor_output_xmm(ctx, v1807);

18697

                                        // Rule at src/isa/x64/lower.isle line 3371.

18698

                                        return Some(v1808);

18699

18700

18701

18702

                            F64X2 => {

18703

                                let v1811 = C::def_inst(ctx, v381);

18704

                                if let Some(v1812) = v1811 {

18705

                                    let v1813 = &C::inst_data(ctx, v1812);

18706

                                    if let &InstructionData::Unary {

18707

                                        opcode: ref v1814,

18708

                                        arg: v1815,

18709

                                    } = v1813

18710

18711

                                        if let &Opcode::SwidenLow = v1814 {

18712

                                            let v1816 = C::value_type(ctx, v1815);

18713

                                            if v1816 == I32X4 {

18714

                                                let v1817 = &C::put_in_xmm_mem(ctx, v1815);

18715

                                                let v1818 = constructor_x64_cvtdq2pd(ctx, v1817);

18716

                                                let v1819 = constructor_output_xmm(ctx, v1818);

18717

                                                // Rule at src/isa/x64/lower.isle line 3377.

18718

                                                return Some(v1819);

18719

18720

18721

18722

18723

18724

                            _ => {}

18725

18726

18727

                    let v622 = C::value_type(ctx, v381);

18728

                    if v622 == I32X4 {

18729

                        let v526 = &C::put_in_xmm_mem(ctx, v381);

18730

                        let v1809 = constructor_x64_cvtdq2ps(ctx, v526);

18731

                        let v1810 = constructor_output_xmm(ctx, v1809);

18732

                        // Rule at src/isa/x64/lower.isle line 3374.

18733

                        return Some(v1810);

18734

18735

18736

                &Opcode::Isplit => {

18737

                    let v622 = C::value_type(ctx, v381);

18738

                    if v622 == I128 {

18739

                        let v385 = C::put_in_regs(ctx, v381);

18740

                        let v2532 = C::value_regs_get(ctx, v385, 0x0);

18741

                        let v2533 = C::value_regs_get(ctx, v385, 0x1);

18742

                        let v2534 = C::value_reg(ctx, v2532);

18743

                        let v2535 = C::value_reg(ctx, v2533);

18744

                        let v2536 = C::output_pair(ctx, v2534, v2535);

18745

                        // Rule at src/isa/x64/lower.isle line 4612.

18746

                        return Some(v2536);

18747

18748

18749

                _ => {}

18750

18751

18752

        &InstructionData::UnaryConst {

18753

            opcode: ref v2242,

18754

            constant_handle: v2243,

18755

        } => {

18756

            if let &Opcode::Vconst = v2242 {

18757

                let v1 = C::first_result(ctx, arg0);

18758

                if let Some(v2) = v1 {

18759

                    let v2244 = C::const_to_vconst(ctx, v2243);

18760

                    let v3 = C::value_type(ctx, v2);

18761

                    let v2245 = constructor_x64_xmm_load_const(ctx, v3, v2244);

18762

                    let v2246 = constructor_output_xmm(ctx, v2245);

18763

                    // Rule at src/isa/x64/lower.isle line 4182.

18764

                    return Some(v2246);

18765

18766

18767

18768

        &InstructionData::UnaryGlobalValue {

18769

            opcode: ref v1688,

18770

            global_value: v1689,

18771

        } => {

18772

            match v1688 {

18773

                &Opcode::SymbolValue => {

18774

                    let v1690 = C::symbol_value_data(ctx, v1689);

18775

                    if let Some(v1691) = v1690 {

18776

                        let v1695 = constructor_load_ext_name(ctx, v1691.0, v1691.2, v1691.1);

18777

                        let v1696 = constructor_output_reg(ctx, v1695);

18778

                        // Rule at src/isa/x64/lower.isle line 3184.

18779

                        return Some(v1696);

18780

18781

18782

                &Opcode::TlsValue => {

18783

                    let v1 = C::first_result(ctx, arg0);

18784

                    if let Some(v2) = v1 {

18785

                        let v1690 = C::symbol_value_data(ctx, v1689);

18786

                        if let Some(v1691) = v1690 {

18787

                            let v3 = C::value_type(ctx, v2);

18788

                            let v2537 = &C::tls_model(ctx, v3);

18789

                            match v2537 {

18790

                                &TlsModel::ElfGd => {

18791

                                    let v2538 = constructor_elf_tls_get_addr(ctx, v1691.0);

18792

                                    let v2539 = constructor_output_gpr(ctx, v2538);

18793

                                    // Rule at src/isa/x64/lower.isle line 4620.

18794

                                    return Some(v2539);

18795

18796

                                &TlsModel::Macho => {

18797

                                    let v2540 = constructor_macho_tls_get_addr(ctx, v1691.0);

18798

                                    let v2541 = constructor_output_gpr(ctx, v2540);

18799

                                    // Rule at src/isa/x64/lower.isle line 4623.

18800

                                    return Some(v2541);

18801

18802

                                &TlsModel::Coff => {

18803

                                    let v2542 = constructor_coff_tls_get_addr(ctx, v1691.0);

18804

                                    let v2543 = constructor_output_gpr(ctx, v2542);

18805

                                    // Rule at src/isa/x64/lower.isle line 4626.

18806

                                    return Some(v2543);

18807

18808

                                _ => {}

18809

18810

18811

18812

18813

                _ => {}

18814

18815

18816

        &InstructionData::UnaryIeee32 {

18817

            opcode: ref v18,

18818

            imm: v19,

18819

        } => {

18820

            if let &Opcode::F32const = v18 {

18821

                let v20 = C::u32_from_ieee32(ctx, v19);

18822

                let v22 = C::u32_as_u64(ctx, v20);

18823

                let v23 = constructor_imm(ctx, F32, v22);

18824

                let v24 = constructor_output_reg(ctx, v23);

18825

                // Rule at src/isa/x64/lower.isle line 27.

18826

                return Some(v24);

18827

18828

18829

        &InstructionData::UnaryIeee64 {

18830

            opcode: ref v25,

18831

            imm: v26,

18832

        } => {

18833

            if let &Opcode::F64const = v25 {

18834

                let v27 = C::u64_from_ieee64(ctx, v26);

18835

                let v29 = constructor_imm(ctx, F64, v27);

18836

                let v30 = constructor_output_reg(ctx, v29);

18837

                // Rule at src/isa/x64/lower.isle line 32.

18838

                return Some(v30);

18839

18840

18841

        &InstructionData::UnaryImm {

18842

            opcode: ref v7,

18843

            imm: v8,

18844

        } => {

18845

            if let &Opcode::Iconst = v7 {

18846

                let v1 = C::first_result(ctx, arg0);

18847

                if let Some(v2) = v1 {

18848

                    let v3 = C::value_type(ctx, v2);

18849

                    if v3 == I128 {

18850

                        let v9 = C::u64_from_imm64(ctx, v8);

18851

                        let v13 = constructor_imm(ctx, I64, v9);

18852

                        let v15 = constructor_imm(ctx, I64, 0x0);

18853

                        let v16 = C::value_regs(ctx, v13, v15);

18854

                        let v17 = C::output(ctx, v16);

18855

                        // Rule at src/isa/x64/lower.isle line 20.

18856

                        return Some(v17);

18857

18858

                    let v4 = C::fits_in_64(ctx, v3);

18859

                    if let Some(v5) = v4 {

18860

                        let v9 = C::u64_from_imm64(ctx, v8);

18861

                        let v10 = constructor_imm(ctx, v5, v9);

18862

                        let v11 = constructor_output_reg(ctx, v10);

18863

                        // Rule at src/isa/x64/lower.isle line 15.

18864

                        return Some(v11);

18865

18866

18867

18868

18869

        _ => {}

18870

18871

    None

18872

18873

18874

// Generated as internal constructor for term lower_branch.

18875

pub fn constructor_lower_branch<C: Context>(

18876

    ctx: &mut C,

18877

    arg0: Inst,

18878

    arg1: &MachLabelSlice,

18879

) -> Option<Unit> {

18880

    let v1 = &C::inst_data(ctx, arg0);

18881

    match v1 {

18882

        &InstructionData::BranchTable {

18883

            opcode: ref v55,

18884

            arg: v56,

18885

            table: v57,

18886

        } => {

18887

            if let &Opcode::BrTable = v55 {

18888

                let v59 = C::jump_table_targets(ctx, arg1);

18889

                if let Some(v60) = v59 {

18890

                    let v58 = C::value_type(ctx, v56);

18891

                    let v63 = &C::raw_operand_size_of_type(ctx, v58);

18892

                    let v64 = C::jump_table_size(ctx, &v60.1);

18893

                    let v65 = C::u32_as_u64(ctx, v64);

18894

                    let v66 = constructor_imm(ctx, v58, v65);

18895

                    let v69 = constructor_extend_to_gpr(ctx, v56, I64, &ExtendKind::Zero);

18896

                    let v70 = &constructor_reg_to_gpr_mem_imm(ctx, v66);

18897

                    let v71 = &constructor_x64_cmp(ctx, v63, v70, v69);

18898

                    let v73 = &C::gpr_to_gpr_mem(ctx, v69);

18899

                    let v74 = C::gpr_new(ctx, v66);

18900

                    let v75 = &constructor_cmove(ctx, v58, &CC::B, v73, v74);

18901

                    let v76 = constructor_with_flags_reg(ctx, v71, v75);

18902

                    let v77 = C::gpr_new(ctx, v76);

18903

                    let v78 = &constructor_jmp_table_seq(ctx, v58, v77, v60.0, &v60.1);

18904

                    let v79 = constructor_emit_side_effect(ctx, v78);

18905

                    // Rule at src/isa/x64/lower.isle line 3313.

18906

                    return Some(v79);

18907

18908

18909

18910

        &InstructionData::Brif {

18911

            opcode: ref v9,

18912

            arg: v10,

18913

            blocks: ref v11,

18914

        } => {

18915

            if let &Opcode::Brif = v9 {

18916

                let v26 = C::two_targets(ctx, arg1);

18917

                if let Some(v27) = v26 {

18918

                    let v12 = C::maybe_uextend(ctx, v10);

18919

                    if let Some(v13) = v12 {

18920

                        let v14 = C::def_inst(ctx, v13);

18921

                        if let Some(v15) = v14 {

18922

                            let v16 = &C::inst_data(ctx, v15);

18923

                            match v16 {

18924

                                &InstructionData::FloatCompare {

18925

                                    opcode: ref v33,

18926

                                    args: ref v34,

18927

                                    cond: ref v35,

18928

                                } => {

18929

                                    if let &Opcode::Fcmp = v33 {

18930

                                        let v36 = C::unpack_value_array_2(ctx, v34);

18931

                                        let v39 = &constructor_emit_fcmp(ctx, v35, v36.0, v36.1);

18932

                                        let v40 =

18933

                                            &constructor_jmp_cond_fcmp(ctx, v39, v27.0, v27.1);

18934

                                        let v41 = constructor_emit_side_effect(ctx, v40);

18935

                                        // Rule at src/isa/x64/lower.isle line 3274.

18936

                                        return Some(v41);

18937

18938

18939

                                &InstructionData::IntCompare {

18940

                                    opcode: ref v17,

18941

                                    args: ref v18,

18942

                                    cond: ref v19,

18943

                                } => {

18944

                                    if let &Opcode::Icmp = v17 {

18945

                                        let v20 = C::unpack_value_array_2(ctx, v18);

18946

                                        let v30 = &constructor_emit_cmp(ctx, v19, v20.0, v20.1);

18947

                                        let v31 =

18948

                                            &constructor_jmp_cond_icmp(ctx, v30, v27.0, v27.1);

18949

                                        let v32 = constructor_emit_side_effect(ctx, v31);

18950

                                        // Rule at src/isa/x64/lower.isle line 3271.

18951

                                        return Some(v32);

18952

18953

18954

                                _ => {}

18955

18956

18957

18958

                    let v42 = C::value_type(ctx, v10);

18959

                    if v42 == I128 {

18960

                        let v44 = C::put_in_regs(ctx, v10);

18961

                        let v45 = &constructor_cmp_zero_i128(ctx, &CC::Z, v44);

18962

                        let v46 = &constructor_jmp_cond_icmp(ctx, v45, v27.0, v27.1);

18963

                        let v47 = constructor_emit_side_effect(ctx, v46);

18964

                        // Rule at src/isa/x64/lower.isle line 3277.

18965

                        return Some(v47);

18966

18967

                    let v48 = C::ty_int_bool_or_ref(ctx, v42);

18968

                    if let Some(v49) = v48 {

18969

                        let v50 = &constructor_cmp_zero_int_bool_ref(ctx, v10);

18970

                        let v52 = &constructor_jmp_cond(ctx, &CC::NZ, v27.0, v27.1);

18971

                        let v53 = &constructor_with_flags_side_effect(ctx, v50, v52);

18972

                        let v54 = constructor_emit_side_effect(ctx, v53);

18973

                        // Rule at src/isa/x64/lower.isle line 3281.

18974

                        return Some(v54);

18975

18976

18977

18978

18979

        &InstructionData::Jump {

18980

            opcode: ref v2,

18981

            destination: v3,

18982

        } => {

18983

            if let &Opcode::Jump = v2 {

18984

                let v5 = C::single_target(ctx, arg1);

18985

                if let Some(v6) = v5 {

18986

                    let v7 = &constructor_jmp_known(ctx, v6);

18987

                    let v8 = constructor_emit_side_effect(ctx, v7);

18988

                    // Rule at src/isa/x64/lower.isle line 3266.

18989

                    return Some(v8);

18990

18991

18992

18993

        _ => {}

18994

18995

    None

18996

18997

18998

// Generated as internal constructor for term construct_overflow_op.

18999

pub fn constructor_construct_overflow_op<C: Context>(

19000

    ctx: &mut C,

19001

    arg0: &CC,

19002

    arg1: &ProducesFlags,

19003

) -> InstOutput {

19004

    let v2 = &constructor_x64_setcc_paired(ctx, arg0);

19005

    let v3 = constructor_with_flags(ctx, arg1, v2);

19006

    let v5 = C::value_regs_get(ctx, v3, 0x0);

19007

    let v6 = C::value_reg(ctx, v5);

19008

    let v8 = C::value_regs_get(ctx, v3, 0x1);

19009

    let v9 = C::value_reg(ctx, v8);

19010

    let v10 = C::output_pair(ctx, v6, v9);

19011

    // Rule at src/isa/x64/lower.isle line 104.

19012

    return v10;

19013

19014

19015

// Generated as internal constructor for term construct_overflow_op_alu.

19016

pub fn constructor_construct_overflow_op_alu<C: Context>(

19017

    ctx: &mut C,

19018

    arg0: Type,

19019

    arg1: &CC,

19020

    arg2: &AluRmiROpcode,

19021

    arg3: Gpr,

19022

    arg4: &GprMemImm,

19023

) -> InstOutput {

19024

    let v5 = &constructor_x64_alurmi_with_flags_paired(ctx, arg2, arg0, arg3, arg4);

19025

    let v6 = constructor_construct_overflow_op(ctx, arg1, v5);

19026

    // Rule at src/isa/x64/lower.isle line 111.

19027

    return v6;

19028

19029

19030

// Generated as internal constructor for term construct_overflow_op_alu_128.

19031

pub fn constructor_construct_overflow_op_alu_128<C: Context>(

19032

    ctx: &mut C,

19033

    arg0: &CC,

19034

    arg1: &AluRmiROpcode,

19035

    arg2: &AluRmiROpcode,

19036

    arg3: Value,

19037

    arg4: Value,

19038

) -> InstOutput {

19039

    let v5 = C::put_in_regs(ctx, arg3);

19040

    let v7 = constructor_value_regs_get_gpr(ctx, v5, 0x0);

19041

    let v9 = constructor_value_regs_get_gpr(ctx, v5, 0x1);

19042

    let v10 = C::put_in_regs(ctx, arg4);

19043

    let v11 = constructor_value_regs_get_gpr(ctx, v10, 0x0);

19044

    let v12 = constructor_value_regs_get_gpr(ctx, v10, 0x1);

19045

    let v14 = &C::gpr_to_gpr_mem_imm(ctx, v11);

19046

    let v15 = &constructor_x64_alurmi_with_flags_paired(ctx, arg1, I64, v7, v14);

19047

    let v16 = &C::gpr_to_gpr_mem_imm(ctx, v12);

19048

    let v17 = &constructor_x64_alurmi_with_flags_chained(ctx, arg2, I64, v9, v16);

19049

    let v18 = &constructor_x64_setcc_paired(ctx, arg0);

19050

    let v19 = &constructor_with_flags_chained(ctx, v15, v17, v18);

19051

    let v20 = constructor_multi_reg_to_pair_and_single(ctx, v19);

19052

    // Rule at src/isa/x64/lower.isle line 119.

19053

    return v20;

19054

19055

19056

// Generated as internal constructor for term sse_and.

19057

pub fn constructor_sse_and<C: Context>(ctx: &mut C, arg0: Type, arg1: Xmm, arg2: &XmmMem) -> Xmm {

19058

    match arg0 {

19059

        F32 => {

19060

            let v3 = constructor_x64_andps(ctx, arg1, arg2);

19061

            // Rule at src/isa/x64/lower.isle line 293.

19062

            return v3;

19063

19064

        F64 => {

19065

            let v4 = constructor_x64_andpd(ctx, arg1, arg2);

19066

            // Rule at src/isa/x64/lower.isle line 294.

19067

            return v4;

19068

19069

        F32X4 => {

19070

            let v3 = constructor_x64_andps(ctx, arg1, arg2);

19071

            // Rule at src/isa/x64/lower.isle line 291.

19072

            return v3;

19073

19074

        F64X2 => {

19075

            let v4 = constructor_x64_andpd(ctx, arg1, arg2);

19076

            // Rule at src/isa/x64/lower.isle line 292.

19077

            return v4;

19078

19079

        _ => {}

19080

19081

    let v5 = C::multi_lane(ctx, arg0);

19082

    if let Some(v6) = v5 {

19083

        let v9 = constructor_x64_pand(ctx, arg1, arg2);

19084

        // Rule at src/isa/x64/lower.isle line 295.

19085

        return v9;

19086

19087

    unreachable!(

19088

        "no rule matched for term {} at {}; should it be partial?",

19089

        "sse_and", "src/isa/x64/lower.isle line 290"

19090

19091

19092

19093

// Generated as internal constructor for term and_i128.

19094

pub fn constructor_and_i128<C: Context>(

19095

    ctx: &mut C,

19096

    arg0: ValueRegs,

19097

    arg1: ValueRegs,

19098

) -> ValueRegs {

19099

    let v3 = constructor_value_regs_get_gpr(ctx, arg0, 0x0);

19100

    let v5 = constructor_value_regs_get_gpr(ctx, arg0, 0x1);

19101

    let v6 = constructor_value_regs_get_gpr(ctx, arg1, 0x0);

19102

    let v7 = constructor_value_regs_get_gpr(ctx, arg1, 0x1);

19103

    let v9 = &C::gpr_to_gpr_mem_imm(ctx, v6);

19104

    let v10 = constructor_x64_and(ctx, I64, v3, v9);

19105

    let v11 = &C::gpr_to_gpr_mem_imm(ctx, v7);

19106

    let v12 = constructor_x64_and(ctx, I64, v5, v11);

19107

    let v13 = constructor_value_gprs(ctx, v10, v12);

19108

    // Rule at src/isa/x64/lower.isle line 304.

19109

    return v13;

19110

19111

19112

// Generated as internal constructor for term sse_and_not.

19113

pub fn constructor_sse_and_not<C: Context>(

19114

    ctx: &mut C,

19115

    arg0: Type,

19116

    arg1: Xmm,

19117

    arg2: &XmmMem,

19118

) -> Xmm {

19119

    match arg0 {

19120

        F32X4 => {

19121

            let v3 = constructor_x64_andnps(ctx, arg1, arg2);

19122

            // Rule at src/isa/x64/lower.isle line 322.

19123

            return v3;

19124

19125

        F64X2 => {

19126

            let v4 = constructor_x64_andnpd(ctx, arg1, arg2);

19127

            // Rule at src/isa/x64/lower.isle line 323.

19128

            return v4;

19129

19130

        _ => {}

19131

19132

    let v5 = C::multi_lane(ctx, arg0);

19133

    if let Some(v6) = v5 {

19134

        let v9 = constructor_x64_pandn(ctx, arg1, arg2);

19135

        // Rule at src/isa/x64/lower.isle line 324.

19136

        return v9;

19137

19138

    unreachable!(

19139

        "no rule matched for term {} at {}; should it be partial?",

19140

        "sse_and_not", "src/isa/x64/lower.isle line 321"

19141

19142

19143

19144

// Generated as internal constructor for term val_minus_one.

19145

pub fn constructor_val_minus_one<C: Context>(ctx: &mut C, arg0: Value) -> Option<Value> {

19146

    let v1 = C::def_inst(ctx, arg0);

19147

    if let Some(v2) = v1 {

19148

        let v3 = &C::inst_data(ctx, v2);

19149

        if let &InstructionData::Binary {

19150

            opcode: ref v4,

19151

            args: ref v5,

19152

        } = v3

19153

19154

            match v4 {

19155

                &Opcode::Iadd => {

19156

                    let v6 = C::unpack_value_array_2(ctx, v5);

19157

                    let v17 = C::i64_from_iconst(ctx, v6.0);

19158

                    if let Some(v18) = v17 {

19159

                        if v18 == -0x1 {

19160

                            // Rule at src/isa/x64/lower.isle line 353.

19161

                            return Some(v6.1);

19162

19163

19164

                    let v15 = C::i64_from_iconst(ctx, v6.1);

19165

                    if let Some(v16) = v15 {

19166

                        if v16 == -0x1 {

19167

                            // Rule at src/isa/x64/lower.isle line 352.

19168

                            return Some(v6.0);

19169

19170

19171

19172

                &Opcode::Isub => {

19173

                    let v6 = C::unpack_value_array_2(ctx, v5);

19174

                    let v9 = C::def_inst(ctx, v6.1);

19175

                    if let Some(v10) = v9 {

19176

                        let v11 = &C::inst_data(ctx, v10);

19177

                        if let &InstructionData::UnaryImm {

19178

                            opcode: ref v12,

19179

                            imm: v13,

19180

                        } = v11

19181

19182

                            if let &Opcode::Iconst = v12 {

19183

                                let v14 = C::u64_from_imm64(ctx, v13);

19184

                                if v14 == 0x1 {

19185

                                    // Rule at src/isa/x64/lower.isle line 351.

19186

                                    return Some(v6.0);

19187

19188

19189

19190

19191

19192

                _ => {}

19193

19194

19195

19196

    None

19197

19198

19199

// Generated as internal constructor for term sse_or.

19200

pub fn constructor_sse_or<C: Context>(ctx: &mut C, arg0: Type, arg1: Xmm, arg2: &XmmMem) -> Xmm {

19201

    match arg0 {

19202

        F32 => {

19203

            let v3 = constructor_x64_orps(ctx, arg1, arg2);

19204

            // Rule at src/isa/x64/lower.isle line 417.

19205

            return v3;

19206

19207

        F64 => {

19208

            let v4 = constructor_x64_orpd(ctx, arg1, arg2);

19209

            // Rule at src/isa/x64/lower.isle line 418.

19210

            return v4;

19211

19212

        F32X4 => {

19213

            let v3 = constructor_x64_orps(ctx, arg1, arg2);

19214

            // Rule at src/isa/x64/lower.isle line 415.

19215

            return v3;

19216

19217

        F64X2 => {

19218

            let v4 = constructor_x64_orpd(ctx, arg1, arg2);

19219

            // Rule at src/isa/x64/lower.isle line 416.

19220

            return v4;

19221

19222

        _ => {}

19223

19224

    let v5 = C::multi_lane(ctx, arg0);

19225

    if let Some(v6) = v5 {

19226

        let v9 = constructor_x64_por(ctx, arg1, arg2);

19227

        // Rule at src/isa/x64/lower.isle line 419.

19228

        return v9;

19229

19230

    unreachable!(

19231

        "no rule matched for term {} at {}; should it be partial?",

19232

        "sse_or", "src/isa/x64/lower.isle line 414"

19233

19234

19235

19236

// Generated as internal constructor for term or_i128.

19237

pub fn constructor_or_i128<C: Context>(ctx: &mut C, arg0: ValueRegs, arg1: ValueRegs) -> ValueRegs {

19238

    let v3 = constructor_value_regs_get_gpr(ctx, arg0, 0x0);

19239

    let v5 = constructor_value_regs_get_gpr(ctx, arg0, 0x1);

19240

    let v6 = constructor_value_regs_get_gpr(ctx, arg1, 0x0);

19241

    let v7 = constructor_value_regs_get_gpr(ctx, arg1, 0x1);

19242

    let v9 = &C::gpr_to_gpr_mem_imm(ctx, v6);

19243

    let v10 = constructor_x64_or(ctx, I64, v3, v9);

19244

    let v11 = &C::gpr_to_gpr_mem_imm(ctx, v7);

19245

    let v12 = constructor_x64_or(ctx, I64, v5, v11);

19246

    let v13 = constructor_value_gprs(ctx, v10, v12);

19247

    // Rule at src/isa/x64/lower.isle line 428.

19248

    return v13;

19249

19250

19251

// Generated as internal constructor for term shl_i128.

19252

pub fn constructor_shl_i128<C: Context>(ctx: &mut C, arg0: ValueRegs, arg1: Gpr) -> ValueRegs {

19253

    let v3 = constructor_value_regs_get_gpr(ctx, arg0, 0x0);

19254

    let v5 = constructor_value_regs_get_gpr(ctx, arg0, 0x1);

19255

    let v7 = &C::gpr_to_imm8_gpr(ctx, arg1);

19256

    let v8 = constructor_x64_shl(ctx, I64, v3, v7);

19257

    let v9 = &C::gpr_to_imm8_gpr(ctx, arg1);

19258

    let v10 = constructor_x64_shl(ctx, I64, v5, v9);

19259

    let v12 = constructor_imm(ctx, I64, 0x40);

19260

    let v13 = C::gpr_new(ctx, v12);

19261

    let v14 = &C::gpr_to_gpr_mem_imm(ctx, arg1);

19262

    let v15 = constructor_x64_sub(ctx, I64, v13, v14);

19263

    let v16 = &C::gpr_to_imm8_gpr(ctx, v15);

19264

    let v17 = constructor_x64_shr(ctx, I64, v3, v16);

19265

    let v19 = constructor_imm(ctx, I64, 0x0);

19266

    let v20 = C::gpr_new(ctx, v19);

19267

    let v23 = RegMemImm::Imm { simm32: 0x7F };

19268

    let v24 = &C::gpr_mem_imm_new(ctx, &v23);

19269

    let v25 = &constructor_x64_test(ctx, &OperandSize::Size64, v24, arg1);

19270

    let v27 = &C::gpr_to_gpr_mem(ctx, v20);

19271

    let v28 = &constructor_cmove(ctx, I64, &CC::Z, v27, v17);

19272

    let v29 = constructor_with_flags_reg(ctx, v25, v28);

19273

    let v30 = C::gpr_new(ctx, v29);

19274

    let v31 = &C::gpr_to_gpr_mem_imm(ctx, v10);

19275

    let v32 = constructor_x64_or(ctx, I64, v30, v31);

19276

    let v34 = RegMemImm::Imm { simm32: 0x40 };

19277

    let v35 = &C::gpr_mem_imm_new(ctx, &v34);

19278

    let v36 = &constructor_x64_test(ctx, &OperandSize::Size64, v35, arg1);

19279

    let v37 = &C::gpr_to_gpr_mem(ctx, v8);

19280

    let v38 = &constructor_cmove(ctx, I64, &CC::Z, v37, v20);

19281

    let v39 = &C::gpr_to_gpr_mem(ctx, v32);

19282

    let v40 = &constructor_cmove(ctx, I64, &CC::Z, v39, v8);

19283

    let v41 = &constructor_consumes_flags_concat(ctx, v38, v40);

19284

    let v42 = constructor_with_flags(ctx, v36, v41);

19285

    // Rule at src/isa/x64/lower.isle line 502.

19286

    return v42;

19287

19288

19289

// Generated as internal constructor for term ishl_i8x16_mask.

19290

pub fn constructor_ishl_i8x16_mask<C: Context>(ctx: &mut C, arg0: &RegMemImm) -> SyntheticAmode {

19291

    match arg0 {

19292

        &RegMemImm::Reg { reg: v3 } => {

19293

            let v4 = &C::ishl_i8x16_mask_table(ctx);

19294

            let v6 = constructor_x64_lea(ctx, I64, v4);

19295

            let v7 = C::gpr_new(ctx, v3);

19296

            let v9 = &C::imm8_to_imm8_gpr(ctx, 0x4);

19297

            let v10 = constructor_x64_shl(ctx, I64, v7, v9);

19298

            let v13 = C::mem_flags_trusted(ctx);

19299

            let v14 = Amode::ImmRegRegShift {

19300

                simm32: 0x0,

19301

                base: v6,

19302

                index: v10,

19303

                shift: 0x0,

19304

                flags: v13,

19305

};

19306

            let v15 = &C::amode_to_synthetic_amode(ctx, &v14);

19307

            // Rule at src/isa/x64/lower.isle line 576.

19308

            return v15.clone();

19309

19310

        &RegMemImm::Mem { addr: ref v16 } => {

19311

            let v18 = constructor_x64_load(ctx, I64, v16, &ExtKind::None);

19312

            let v19 = RegMemImm::Reg { reg: v18 };

19313

            let v20 = &constructor_ishl_i8x16_mask(ctx, &v19);

19314

            // Rule at src/isa/x64/lower.isle line 587.

19315

            return v20.clone();

19316

19317

        &RegMemImm::Imm { simm32: v1 } => {

19318

            let v2 = &C::ishl_i8x16_mask_for_const(ctx, v1);

19319

            // Rule at src/isa/x64/lower.isle line 567.

19320

            return v2.clone();

19321

19322

        _ => {}

19323

19324

    unreachable!(

19325

        "no rule matched for term {} at {}; should it be partial?",

19326

        "ishl_i8x16_mask", "src/isa/x64/lower.isle line 561"

19327

19328

19329

19330

// Generated as internal constructor for term shr_i128.

19331

pub fn constructor_shr_i128<C: Context>(ctx: &mut C, arg0: ValueRegs, arg1: Gpr) -> ValueRegs {

19332

    let v3 = constructor_value_regs_get_gpr(ctx, arg0, 0x0);

19333

    let v5 = constructor_value_regs_get_gpr(ctx, arg0, 0x1);

19334

    let v7 = &C::gpr_to_imm8_gpr(ctx, arg1);

19335

    let v8 = constructor_x64_shr(ctx, I64, v3, v7);

19336

    let v9 = &C::gpr_to_imm8_gpr(ctx, arg1);

19337

    let v10 = constructor_x64_shr(ctx, I64, v5, v9);

19338

    let v12 = constructor_imm(ctx, I64, 0x40);

19339

    let v13 = C::gpr_new(ctx, v12);

19340

    let v14 = &C::gpr_to_gpr_mem_imm(ctx, arg1);

19341

    let v15 = constructor_x64_sub(ctx, I64, v13, v14);

19342

    let v16 = &C::gpr_to_imm8_gpr(ctx, v15);

19343

    let v17 = constructor_x64_shl(ctx, I64, v5, v16);

19344

    let v19 = constructor_imm(ctx, I64, 0x0);

19345

    let v20 = C::gpr_new(ctx, v19);

19346

    let v23 = RegMemImm::Imm { simm32: 0x7F };

19347

    let v24 = &C::gpr_mem_imm_new(ctx, &v23);

19348

    let v25 = &constructor_x64_test(ctx, &OperandSize::Size64, v24, arg1);

19349

    let v27 = &C::gpr_to_gpr_mem(ctx, v20);

19350

    let v28 = &constructor_cmove(ctx, I64, &CC::Z, v27, v17);

19351

    let v29 = constructor_with_flags_reg(ctx, v25, v28);

19352

    let v30 = C::gpr_new(ctx, v29);

19353

    let v31 = &C::gpr_to_gpr_mem_imm(ctx, v8);

19354

    let v32 = constructor_x64_or(ctx, I64, v30, v31);

19355

    let v34 = RegMemImm::Imm { simm32: 0x40 };

19356

    let v35 = &C::gpr_mem_imm_new(ctx, &v34);

19357

    let v36 = &constructor_x64_test(ctx, &OperandSize::Size64, v35, arg1);

19358

    let v37 = &C::gpr_to_gpr_mem(ctx, v32);

19359

    let v38 = &constructor_cmove(ctx, I64, &CC::Z, v37, v10);

19360

    let v39 = &C::gpr_to_gpr_mem(ctx, v10);

19361

    let v40 = &constructor_cmove(ctx, I64, &CC::Z, v39, v20);

19362

    let v41 = &constructor_consumes_flags_concat(ctx, v38, v40);

19363

    let v42 = constructor_with_flags(ctx, v36, v41);

19364

    // Rule at src/isa/x64/lower.isle line 612.

19365

    return v42;

19366

19367

19368

// Generated as internal constructor for term ushr_i8x16_mask.

19369

pub fn constructor_ushr_i8x16_mask<C: Context>(ctx: &mut C, arg0: &RegMemImm) -> SyntheticAmode {

19370

    match arg0 {

19371

        &RegMemImm::Reg { reg: v3 } => {

19372

            let v4 = &C::ushr_i8x16_mask_table(ctx);

19373

            let v6 = constructor_x64_lea(ctx, I64, v4);

19374

            let v7 = C::gpr_new(ctx, v3);

19375

            let v9 = &C::imm8_to_imm8_gpr(ctx, 0x4);

19376

            let v10 = constructor_x64_shl(ctx, I64, v7, v9);

19377

            let v13 = C::mem_flags_trusted(ctx);

19378

            let v14 = Amode::ImmRegRegShift {

19379

                simm32: 0x0,

19380

                base: v6,

19381

                index: v10,

19382

                shift: 0x0,

19383

                flags: v13,

19384

};

19385

            let v15 = &C::amode_to_synthetic_amode(ctx, &v14);

19386

            // Rule at src/isa/x64/lower.isle line 681.

19387

            return v15.clone();

19388

19389

        &RegMemImm::Mem { addr: ref v16 } => {

19390

            let v18 = constructor_x64_load(ctx, I64, v16, &ExtKind::None);

19391

            let v19 = RegMemImm::Reg { reg: v18 };

19392

            let v20 = &constructor_ushr_i8x16_mask(ctx, &v19);

19393

            // Rule at src/isa/x64/lower.isle line 693.

19394

            return v20.clone();

19395

19396

        &RegMemImm::Imm { simm32: v1 } => {

19397

            let v2 = &C::ushr_i8x16_mask_for_const(ctx, v1);

19398

            // Rule at src/isa/x64/lower.isle line 672.

19399

            return v2.clone();

19400

19401

        _ => {}

19402

19403

    unreachable!(

19404

        "no rule matched for term {} at {}; should it be partial?",

19405

        "ushr_i8x16_mask", "src/isa/x64/lower.isle line 666"

19406

19407

19408

19409

// Generated as internal constructor for term mask_xmm_shift.

19410

pub fn constructor_mask_xmm_shift<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> RegMemImm {

19411

    let v11 = C::def_inst(ctx, arg1);

19412

    if let Some(v12) = v11 {

19413

        let v13 = &C::inst_data(ctx, v12);

19414

        if let &InstructionData::UnaryImm {

19415

            opcode: ref v14,

19416

            imm: v15,

19417

        } = v13

19418

19419

            if let &Opcode::Iconst = v14 {

19420

                let v16 = C::shift_amount_masked(ctx, arg0, v15);

19421

                let v17 = C::u8_as_u32(ctx, v16);

19422

                let v18 = RegMemImm::Imm { simm32: v17 };

19423

                // Rule at src/isa/x64/lower.isle line 710.

19424

                return v18;

19425

19426

19427

19428

    let v3 = constructor_put_in_gpr(ctx, arg1);

19429

    let v4 = C::shift_mask(ctx, arg0);

19430

    let v5 = C::u8_as_u32(ctx, v4);

19431

    let v6 = RegMemImm::Imm { simm32: v5 };

19432

    let v7 = &C::gpr_mem_imm_new(ctx, &v6);

19433

    let v8 = constructor_x64_and(ctx, I64, v3, v7);

19434

    let v9 = C::gpr_to_reg(ctx, v8);

19435

    let v10 = &C::reg_to_reg_mem_imm(ctx, v9);

19436

    // Rule at src/isa/x64/lower.isle line 708.

19437

    return v10.clone();

19438

19439

19440

// Generated as internal constructor for term sar_i128.

19441

pub fn constructor_sar_i128<C: Context>(ctx: &mut C, arg0: ValueRegs, arg1: Gpr) -> ValueRegs {

19442

    let v3 = constructor_value_regs_get_gpr(ctx, arg0, 0x0);

19443

    let v5 = constructor_value_regs_get_gpr(ctx, arg0, 0x1);

19444

    let v7 = &C::gpr_to_imm8_gpr(ctx, arg1);

19445

    let v8 = constructor_x64_shr(ctx, I64, v3, v7);

19446

    let v9 = &C::gpr_to_imm8_gpr(ctx, arg1);

19447

    let v10 = constructor_x64_sar(ctx, I64, v5, v9);

19448

    let v12 = constructor_imm(ctx, I64, 0x40);

19449

    let v13 = C::gpr_new(ctx, v12);

19450

    let v14 = &C::gpr_to_gpr_mem_imm(ctx, arg1);

19451

    let v15 = constructor_x64_sub(ctx, I64, v13, v14);

19452

    let v16 = &C::gpr_to_imm8_gpr(ctx, v15);

19453

    let v17 = constructor_x64_shl(ctx, I64, v5, v16);

19454

    let v20 = RegMemImm::Imm { simm32: 0x7F };

19455

    let v21 = &C::gpr_mem_imm_new(ctx, &v20);

19456

    let v22 = &constructor_x64_test(ctx, &OperandSize::Size64, v21, arg1);

19457

    let v25 = constructor_imm(ctx, I64, 0x0);

19458

    let v26 = &C::reg_to_gpr_mem(ctx, v25);

19459

    let v27 = &constructor_cmove(ctx, I64, &CC::Z, v26, v17);

19460

    let v28 = constructor_with_flags_reg(ctx, v22, v27);

19461

    let v29 = C::gpr_new(ctx, v28);

19462

    let v30 = &C::gpr_to_gpr_mem_imm(ctx, v29);

19463

    let v31 = constructor_x64_or(ctx, I64, v8, v30);

19464

    let v33 = &C::imm8_to_imm8_gpr(ctx, 0x3F);

19465

    let v34 = constructor_x64_sar(ctx, I64, v5, v33);

19466

    let v36 = RegMemImm::Imm { simm32: 0x40 };

19467

    let v37 = &C::gpr_mem_imm_new(ctx, &v36);

19468

    let v38 = &constructor_x64_test(ctx, &OperandSize::Size64, v37, arg1);

19469

    let v39 = &C::gpr_to_gpr_mem(ctx, v31);

19470

    let v40 = &constructor_cmove(ctx, I64, &CC::Z, v39, v10);

19471

    let v41 = &C::gpr_to_gpr_mem(ctx, v10);

19472

    let v42 = &constructor_cmove(ctx, I64, &CC::Z, v41, v34);

19473

    let v43 = &constructor_consumes_flags_concat(ctx, v40, v42);

19474

    let v44 = constructor_with_flags(ctx, v38, v43);

19475

    // Rule at src/isa/x64/lower.isle line 724.

19476

    return v44;

19477

19478

19479

// Generated as internal constructor for term sshr_i8x16_bigger_shift.

19480

pub fn constructor_sshr_i8x16_bigger_shift<C: Context>(

19481

    ctx: &mut C,

19482

    arg0: Type,

19483

    arg1: &RegMemImm,

19484

) -> XmmMemImm {

19485

    match arg1 {

19486

        &RegMemImm::Reg { reg: v7 } => {

19487

            let v8 = C::gpr_new(ctx, v7);

19488

            let v9 = RegMemImm::Imm { simm32: 0x8 };

19489

            let v10 = &C::gpr_mem_imm_new(ctx, &v9);

19490

            let v11 = constructor_x64_add(ctx, arg0, v8, v10);

19491

            let v12 = C::gpr_to_reg(ctx, v11);

19492

            let v13 = RegMemImm::Reg { reg: v12 };

19493

            let v14 = &constructor_mov_rmi_to_xmm(ctx, &v13);

19494

            // Rule at src/isa/x64/lower.isle line 792.

19495

            return v14.clone();

19496

19497

        &RegMemImm::Mem { addr: ref v15 } => {

19498

            let v17 = constructor_imm(ctx, arg0, 0x8);

19499

            let v18 = C::gpr_new(ctx, v17);

19500

            let v19 = &C::gpr_mem_imm_new(ctx, arg1);

19501

            let v20 = constructor_x64_add(ctx, arg0, v18, v19);

19502

            let v21 = C::gpr_to_reg(ctx, v20);

19503

            let v22 = RegMemImm::Reg { reg: v21 };

19504

            let v23 = &constructor_mov_rmi_to_xmm(ctx, &v22);

19505

            // Rule at src/isa/x64/lower.isle line 796.

19506

            return v23.clone();

19507

19508

        &RegMemImm::Imm { simm32: v2 } => {

19509

            let v4 = C::u32_add(ctx, v2, 0x8);

19510

            let v5 = RegMemImm::Imm { simm32: v4 };

19511

            let v6 = &C::xmm_mem_imm_new(ctx, &v5);

19512

            // Rule at src/isa/x64/lower.isle line 790.

19513

            return v6.clone();

19514

19515

        _ => {}

19516

19517

    unreachable!(

19518

        "no rule matched for term {} at {}; should it be partial?",

19519

        "sshr_i8x16_bigger_shift", "src/isa/x64/lower.isle line 789"

19520

19521

19522

19523

// Generated as internal constructor for term lower_i64x2_sshr_imm.

19524

pub fn constructor_lower_i64x2_sshr_imm<C: Context>(ctx: &mut C, arg0: Xmm, arg1: u32) -> Xmm {

19525

    let v2 = C::u32_as_u64(ctx, arg1);

19526

    let v4 = C::u64_lt(ctx, v2, 0x20);

19527

    if v4 == true {

19528

        let v5 = &C::xmi_imm(ctx, arg1);

19529

        let v6 = constructor_x64_psrad(ctx, arg0, v5);

19530

        let v7 = &C::xmm_to_xmm_mem(ctx, v6);

19531

        let v9 = constructor_x64_pshufd(ctx, v7, 0xED);

19532

        let v10 = &C::xmi_imm(ctx, arg1);

19533

        let v11 = constructor_x64_psrlq(ctx, arg0, v10);

19534

        let v12 = &C::xmm_to_xmm_mem(ctx, v11);

19535

        let v14 = constructor_x64_pshufd(ctx, v12, 0xE8);

19536

        let v15 = &C::xmm_to_xmm_mem(ctx, v9);

19537

        let v16 = constructor_x64_punpckldq(ctx, v14, v15);

19538

        // Rule at src/isa/x64/lower.isle line 835.

19539

        return v16;

19540

19541

    if arg1 == 0x20 {

19542

        let v17 = &C::xmm_to_xmm_mem(ctx, arg0);

19543

        let v18 = constructor_x64_pshufd(ctx, v17, 0xED);

19544

        let v20 = &C::xmi_imm(ctx, 0x1F);

19545

        let v21 = constructor_x64_psrad(ctx, arg0, v20);

19546

        let v22 = &C::xmm_to_xmm_mem(ctx, v21);

19547

        let v23 = constructor_x64_pshufd(ctx, v22, 0xED);

19548

        let v24 = &C::xmm_to_xmm_mem(ctx, v23);

19549

        let v25 = constructor_x64_punpckldq(ctx, v18, v24);

19550

        // Rule at src/isa/x64/lower.isle line 846.

19551

        return v25;

19552

19553

    let v26 = C::u64_lt(ctx, 0x20, v2);

19554

    if v26 == true {

19555

        let v27 = &C::xmi_imm(ctx, 0x1F);

19556

        let v28 = constructor_x64_psrad(ctx, arg0, v27);

19557

        let v29 = &C::xmm_to_xmm_mem(ctx, v28);

19558

        let v30 = constructor_x64_pshufd(ctx, v29, 0xED);

19559

        let v32 = C::u32_sub(ctx, arg1, 0x20);

19560

        let v33 = &C::xmi_imm(ctx, v32);

19561

        let v34 = constructor_x64_psrad(ctx, arg0, v33);

19562

        let v35 = &C::xmm_to_xmm_mem(ctx, v34);

19563

        let v36 = constructor_x64_pshufd(ctx, v35, 0xED);

19564

        let v37 = &C::xmm_to_xmm_mem(ctx, v30);

19565

        let v38 = constructor_x64_punpckldq(ctx, v36, v37);

19566

        // Rule at src/isa/x64/lower.isle line 857.

19567

        return v38;

19568

19569

    unreachable!(

19570

        "no rule matched for term {} at {}; should it be partial?",

19571

        "lower_i64x2_sshr_imm", "src/isa/x64/lower.isle line 830"

19572

19573

19574

19575

// Generated as internal constructor for term lower_i64x2_sshr_gpr.

19576

pub fn constructor_lower_i64x2_sshr_gpr<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Gpr) -> Xmm {

19577

    let v2 = &C::gpr_to_gpr_mem(ctx, arg1);

19578

    let v3 = constructor_x64_movq_to_xmm(ctx, v2);

19579

    let v5 = constructor_flip_high_bit_mask(ctx, I64X2);

19580

    let v6 = &C::xmm_to_xmm_mem_imm(ctx, v3);

19581

    let v7 = constructor_x64_psrlq(ctx, v5, v6);

19582

    let v8 = &C::xmm_to_xmm_mem_imm(ctx, v3);

19583

    let v9 = constructor_x64_psrlq(ctx, arg0, v8);

19584

    let v10 = &C::xmm_to_xmm_mem(ctx, v9);

19585

    let v11 = constructor_x64_pxor(ctx, v7, v10);

19586

    let v12 = &C::xmm_to_xmm_mem(ctx, v7);

19587

    let v13 = constructor_x64_psubq(ctx, v11, v12);

19588

    // Rule at src/isa/x64/lower.isle line 872.

19589

    return v13;

19590

19591

19592

// Generated as internal constructor for term lower_bmask.

19593

pub fn constructor_lower_bmask<C: Context>(

19594

    ctx: &mut C,

19595

    arg0: Type,

19596

    arg1: Type,

19597

    arg2: ValueRegs,

19598

) -> ValueRegs {

19599

    if arg0 == I128 {

19600

        let v23 = constructor_lower_bmask(ctx, I64, arg1, arg2);

19601

        let v24 = constructor_value_regs_get_gpr(ctx, v23, 0x0);

19602

        let v25 = C::gpr_to_reg(ctx, v24);

19603

        let v26 = C::gpr_to_reg(ctx, v24);

19604

        let v27 = C::value_regs(ctx, v25, v26);

19605

        // Rule at src/isa/x64/lower.isle line 1335.

19606

        return v27;

19607

19608

    let v1 = C::fits_in_64(ctx, arg0);

19609

    if let Some(v2) = v1 {

19610

        if arg1 == I128 {

19611

            let v8 = constructor_value_regs_get_gpr(ctx, arg2, 0x0);

19612

            let v16 = constructor_value_regs_get_gpr(ctx, arg2, 0x1);

19613

            let v18 = &C::gpr_to_gpr_mem_imm(ctx, v16);

19614

            let v19 = constructor_x64_or(ctx, I64, v8, v18);

19615

            let v20 = C::gpr_to_reg(ctx, v19);

19616

            let v21 = C::value_reg(ctx, v20);

19617

            let v22 = constructor_lower_bmask(ctx, v2, I64, v21);

19618

            // Rule at src/isa/x64/lower.isle line 1327.

19619

            return v22;

19620

19621

        let v4 = C::fits_in_64(ctx, arg1);

19622

        if let Some(v5) = v4 {

19623

            let v8 = constructor_value_regs_get_gpr(ctx, arg2, 0x0);

19624

            let v9 = &constructor_x64_neg_paired(ctx, v5, v8);

19625

            let v10 = &C::gpr_to_gpr_mem_imm(ctx, v8);

19626

            let v11 = &constructor_x64_sbb_paired(ctx, v2, v8, v10);

19627

            let v12 = constructor_with_flags(ctx, v9, v11);

19628

            let v14 = C::value_regs_get(ctx, v12, 0x1);

19629

            let v15 = C::value_reg(ctx, v14);

19630

            // Rule at src/isa/x64/lower.isle line 1316.

19631

            return v15;

19632

19633

19634

    unreachable!(

19635

        "no rule matched for term {} at {}; should it be partial?",

19636

        "lower_bmask", "src/isa/x64/lower.isle line 1304"

19637

19638

19639

19640

// Generated as internal constructor for term i128_not.

19641

pub fn constructor_i128_not<C: Context>(ctx: &mut C, arg0: Value) -> ValueRegs {

19642

    let v1 = C::put_in_regs(ctx, arg0);

19643

    let v3 = constructor_value_regs_get_gpr(ctx, v1, 0x0);

19644

    let v5 = constructor_value_regs_get_gpr(ctx, v1, 0x1);

19645

    let v7 = constructor_x64_not(ctx, I64, v3);

19646

    let v8 = constructor_x64_not(ctx, I64, v5);

19647

    let v9 = constructor_value_gprs(ctx, v7, v8);

19648

    // Rule at src/isa/x64/lower.isle line 1358.

19649

    return v9;

19650

19651

19652

// Generated as internal constructor for term all_ones_or_all_zeros.

19653

pub fn constructor_all_ones_or_all_zeros<C: Context>(ctx: &mut C, arg0: Value) -> Option<bool> {

19654

    let v1 = C::def_inst(ctx, arg0);

19655

    if let Some(v2) = v1 {

19656

        let v3 = &C::inst_data(ctx, v2);

19657

        match v3 {

19658

            &InstructionData::FloatCompare {

19659

                opcode: ref v16,

19660

                args: ref v17,

19661

                cond: ref v18,

19662

            } => {

19663

                if let &Opcode::Fcmp = v16 {

19664

                    let v10 = C::value_type(ctx, arg0);

19665

                    let v11 = C::multi_lane(ctx, v10);

19666

                    if let Some(v12) = v11 {

19667

                        // Rule at src/isa/x64/lower.isle line 1404.

19668

                        return Some(true);

19669

19670

19671

19672

            &InstructionData::IntCompare {

19673

                opcode: ref v4,

19674

                args: ref v5,

19675

                cond: ref v6,

19676

            } => {

19677

                if let &Opcode::Icmp = v4 {

19678

                    let v10 = C::value_type(ctx, arg0);

19679

                    let v11 = C::multi_lane(ctx, v10);

19680

                    if let Some(v12) = v11 {

19681

                        // Rule at src/isa/x64/lower.isle line 1403.

19682

                        return Some(true);

19683

19684

19685

19686

            &InstructionData::UnaryConst {

19687

                opcode: ref v22,

19688

                constant_handle: v23,

19689

            } => {

19690

                if let &Opcode::Vconst = v22 {

19691

                    let v24 = C::vconst_all_ones_or_all_zeros(ctx, v23);

19692

                    if let Some(v25) = v24 {

19693

                        // Rule at src/isa/x64/lower.isle line 1405.

19694

                        return Some(true);

19695

19696

19697

19698

            _ => {}

19699

19700

19701

    None

19702

19703

19704

// Generated as internal constructor for term vec_insert_lane.

19705

pub fn constructor_vec_insert_lane<C: Context>(

19706

    ctx: &mut C,

19707

    arg0: Type,

19708

    arg1: Xmm,

19709

    arg2: &RegMem,

19710

    arg3: u8,

19711

) -> Xmm {

19712

    match arg0 {

19713

        I8X16 => {

19714

            let v4 = C::use_sse41(ctx);

19715

            if v4 == true {

19716

                let v5 = &C::reg_mem_to_gpr_mem(ctx, arg2);

19717

                let v6 = constructor_x64_pinsrb(ctx, arg1, v5, arg3);

19718

                // Rule at src/isa/x64/lower.isle line 1473.

19719

                return v6;

19720

19721

            let v7 = C::insert_i8x16_lane_hole(ctx, arg3);

19722

            let v8 = &constructor_const_to_xmm_mem(ctx, v7);

19723

            let v9 = constructor_x64_pand(ctx, arg1, v8);

19724

            let v11 = &C::reg_mem_to_gpr_mem(ctx, arg2);

19725

            let v12 = constructor_x64_movzx(ctx, &ExtMode::BL, v11);

19726

            let v15 = C::u8_and(ctx, arg3, 0x3);

19727

            let v16 = C::u8_shl(ctx, v15, 0x3);

19728

            let v17 = Imm8Reg::Imm8 { imm: v16 };

19729

            let v18 = &C::imm8_reg_to_imm8_gpr(ctx, &v17);

19730

            let v19 = constructor_x64_shl(ctx, I32, v12, v18);

19731

            let v20 = &C::gpr_to_gpr_mem(ctx, v19);

19732

            let v21 = constructor_x64_movd_to_xmm(ctx, v20);

19733

            let v22 = &C::xmm_to_xmm_mem(ctx, v21);

19734

            let v24 = C::u8_shr(ctx, arg3, 0x2);

19735

            let v25 = constructor_insert_i8x16_lane_pshufd_imm(ctx, v24);

19736

            let v26 = constructor_x64_pshufd(ctx, v22, v25);

19737

            let v27 = &C::xmm_to_xmm_mem(ctx, v26);

19738

            let v28 = constructor_x64_por(ctx, v9, v27);

19739

            // Rule at src/isa/x64/lower.isle line 1501.

19740

            return v28;

19741

19742

        I16X8 => {

19743

            let v5 = &C::reg_mem_to_gpr_mem(ctx, arg2);

19744

            let v29 = constructor_x64_pinsrw(ctx, arg1, v5, arg3);

19745

            // Rule at src/isa/x64/lower.isle line 1518.

19746

            return v29;

19747

19748

        I32X4 => {

19749

            let v4 = C::use_sse41(ctx);

19750

            if v4 == true {

19751

                let v5 = &C::reg_mem_to_gpr_mem(ctx, arg2);

19752

                let v30 = constructor_x64_pinsrd(ctx, arg1, v5, arg3);

19753

                // Rule at src/isa/x64/lower.isle line 1522.

19754

                return v30;

19755

19756

            match arg3 {

19757

                0x0 => {

19758

                    let v5 = &C::reg_mem_to_gpr_mem(ctx, arg2);

19759

                    let v31 = constructor_x64_movd_to_xmm(ctx, v5);

19760

                    let v32 = constructor_x64_movss_regmove(ctx, arg1, v31);

19761

                    // Rule at src/isa/x64/lower.isle line 1526.

19762

                    return v32;

19763

19764

                0x1 => {

19765

                    let v5 = &C::reg_mem_to_gpr_mem(ctx, arg2);

19766

                    let v31 = constructor_x64_movd_to_xmm(ctx, v5);

19767

                    let v33 = &C::xmm_to_xmm_mem(ctx, arg1);

19768

                    let v34 = constructor_x64_punpcklqdq(ctx, v31, v33);

19769

                    let v35 = &C::xmm_to_xmm_mem(ctx, arg1);

19770

                    let v37 = constructor_x64_shufps(ctx, v34, v35, 0xE2);

19771

                    // Rule at src/isa/x64/lower.isle line 1531.

19772

                    return v37;

19773

19774

                0x2 => {

19775

                    let v5 = &C::reg_mem_to_gpr_mem(ctx, arg2);

19776

                    let v31 = constructor_x64_movd_to_xmm(ctx, v5);

19777

                    let v33 = &C::xmm_to_xmm_mem(ctx, arg1);

19778

                    let v39 = constructor_x64_shufps(ctx, v31, v33, 0x30);

19779

                    let v40 = &C::xmm_to_xmm_mem(ctx, v39);

19780

                    let v42 = constructor_x64_shufps(ctx, arg1, v40, 0x84);

19781

                    // Rule at src/isa/x64/lower.isle line 1538.

19782

                    return v42;

19783

19784

                0x3 => {

19785

                    let v5 = &C::reg_mem_to_gpr_mem(ctx, arg2);

19786

                    let v31 = constructor_x64_movd_to_xmm(ctx, v5);

19787

                    let v33 = &C::xmm_to_xmm_mem(ctx, arg1);

19788

                    let v44 = constructor_x64_shufps(ctx, v31, v33, 0xE4);

19789

                    let v45 = &C::xmm_to_xmm_mem(ctx, v44);

19790

                    let v47 = constructor_x64_shufps(ctx, arg1, v45, 0x24);

19791

                    // Rule at src/isa/x64/lower.isle line 1545.

19792

                    return v47;

19793

19794

                _ => {}

19795

19796

19797

        I64X2 => {

19798

            let v4 = C::use_sse41(ctx);

19799

            if v4 == true {

19800

                let v5 = &C::reg_mem_to_gpr_mem(ctx, arg2);

19801

                let v48 = constructor_x64_pinsrq(ctx, arg1, v5, arg3);

19802

                // Rule at src/isa/x64/lower.isle line 1551.

19803

                return v48;

19804

19805

            match arg3 {

19806

                0x0 => {

19807

                    let v5 = &C::reg_mem_to_gpr_mem(ctx, arg2);

19808

                    let v49 = constructor_x64_movq_to_xmm(ctx, v5);

19809

                    let v50 = constructor_x64_movsd_regmove(ctx, arg1, v49);

19810

                    // Rule at src/isa/x64/lower.isle line 1554.

19811

                    return v50;

19812

19813

                0x1 => {

19814

                    let v5 = &C::reg_mem_to_gpr_mem(ctx, arg2);

19815

                    let v49 = constructor_x64_movq_to_xmm(ctx, v5);

19816

                    let v51 = &C::xmm_to_xmm_mem(ctx, v49);

19817

                    let v52 = constructor_x64_punpcklqdq(ctx, arg1, v51);

19818

                    // Rule at src/isa/x64/lower.isle line 1556.

19819

                    return v52;

19820

19821

                _ => {}

19822

19823

19824

        F32X4 => {

19825

            let v4 = C::use_sse41(ctx);

19826

            if v4 == true {

19827

                let v53 = &C::reg_mem_to_xmm_mem(ctx, arg2);

19828

                let v54 = C::sse_insertps_lane_imm(ctx, arg3);

19829

                let v55 = constructor_x64_insertps(ctx, arg1, v53, v54);

19830

                // Rule at src/isa/x64/lower.isle line 1560.

19831

                return v55;

19832

19833

            match arg2 {

19834

                &RegMem::Reg { reg: v56 } => {

19835

                    match arg3 {

19836

                        0x0 => {

19837

                            let v57 = C::xmm_new(ctx, v56);

19838

                            let v58 = constructor_x64_movss_regmove(ctx, arg1, v57);

19839

                            // Rule at src/isa/x64/lower.isle line 1565.

19840

                            return v58;

19841

19842

                        0x1 => {

19843

                            let v57 = C::xmm_new(ctx, v56);

19844

                            let v59 = &C::xmm_to_xmm_mem(ctx, arg1);

19845

                            let v60 = constructor_x64_movlhps(ctx, v57, v59);

19846

                            let v61 = &C::xmm_to_xmm_mem(ctx, arg1);

19847

                            let v62 = constructor_x64_shufps(ctx, v60, v61, 0xE2);

19848

                            // Rule at src/isa/x64/lower.isle line 1571.

19849

                            return v62;

19850

19851

                        0x2 => {

19852

                            let v57 = C::xmm_new(ctx, v56);

19853

                            let v59 = &C::xmm_to_xmm_mem(ctx, arg1);

19854

                            let v63 = constructor_x64_shufps(ctx, v57, v59, 0x30);

19855

                            let v64 = &C::xmm_to_xmm_mem(ctx, v63);

19856

                            let v65 = constructor_x64_shufps(ctx, arg1, v64, 0x84);

19857

                            // Rule at src/isa/x64/lower.isle line 1578.

19858

                            return v65;

19859

19860

                        0x3 => {

19861

                            let v57 = C::xmm_new(ctx, v56);

19862

                            let v59 = &C::xmm_to_xmm_mem(ctx, arg1);

19863

                            let v66 = constructor_x64_shufps(ctx, v57, v59, 0xE4);

19864

                            let v67 = &C::xmm_to_xmm_mem(ctx, v66);

19865

                            let v68 = constructor_x64_shufps(ctx, arg1, v67, 0x24);

19866

                            // Rule at src/isa/x64/lower.isle line 1585.

19867

                            return v68;

19868

19869

                        _ => {}

19870

19871

19872

                &RegMem::Mem { addr: ref v69 } => {

19873

                    let v71 = constructor_x64_movss_load(ctx, v69);

19874

                    let v72 = C::xmm_to_reg(ctx, v71);

19875

                    let v73 = &constructor_xmm_to_reg_mem(ctx, v72);

19876

                    let v74 = &C::xmm_mem_to_reg_mem(ctx, v73);

19877

                    let v75 = constructor_vec_insert_lane(ctx, F32X4, arg1, v74, arg3);

19878

                    // Rule at src/isa/x64/lower.isle line 1590.

19879

                    return v75;

19880

19881

                _ => {}

19882

19883

19884

        F64X2 => {

19885

            match arg3 {

19886

                0x0 => {

19887

                    match arg2 {

19888

                        &RegMem::Reg { reg: v56 } => {

19889

                            let v57 = C::xmm_new(ctx, v56);

19890

                            let v76 = constructor_x64_movsd_regmove(ctx, arg1, v57);

19891

                            // Rule at src/isa/x64/lower.isle line 1602.

19892

                            return v76;

19893

19894

                        &RegMem::Mem { addr: ref v69 } => {

19895

                            let v77 = constructor_x64_movsd_load(ctx, v69);

19896

                            let v78 = constructor_x64_movsd_regmove(ctx, arg1, v77);

19897

                            // Rule at src/isa/x64/lower.isle line 1604.

19898

                            return v78;

19899

19900

                        _ => {}

19901

19902

19903

                0x1 => {

19904

                    let v53 = &C::reg_mem_to_xmm_mem(ctx, arg2);

19905

                    let v79 = constructor_x64_movlhps(ctx, arg1, v53);

19906

                    // Rule at src/isa/x64/lower.isle line 1612.

19907

                    return v79;

19908

19909

                _ => {}

19910

19911

19912

        _ => {}

19913

19914

    unreachable!(

19915

        "no rule matched for term {} at {}; should it be partial?",

19916

        "vec_insert_lane", "src/isa/x64/lower.isle line 1470"

19917

19918

19919

19920

// Generated as internal constructor for term insert_i8x16_lane_pshufd_imm.

19921

pub fn constructor_insert_i8x16_lane_pshufd_imm<C: Context>(ctx: &mut C, arg0: u8) -> u8 {

19922

    match arg0 {

19923

        0x0 => {

19924

            // Rule at src/isa/x64/lower.isle line 1512.

19925

            return 0x54;

19926

19927

        0x1 => {

19928

            // Rule at src/isa/x64/lower.isle line 1513.

19929

            return 0x51;

19930

19931

        0x2 => {

19932

            // Rule at src/isa/x64/lower.isle line 1514.

19933

            return 0x45;

19934

19935

        0x3 => {

19936

            // Rule at src/isa/x64/lower.isle line 1515.

19937

            return 0x15;

19938

19939

        _ => {}

19940

19941

    unreachable!(

19942

        "no rule matched for term {} at {}; should it be partial?",

19943

        "insert_i8x16_lane_pshufd_imm", "src/isa/x64/lower.isle line 1511"

19944

19945

19946

19947

// Generated as internal constructor for term cmp_and_choose.

19948

pub fn constructor_cmp_and_choose<C: Context>(

19949

    ctx: &mut C,

19950

    arg0: Type,

19951

    arg1: &CC,

19952

    arg2: Value,

19953

    arg3: Value,

19954

) -> ValueRegs {

19955

    let v1 = C::fits_in_64(ctx, arg0);

19956

    if let Some(v2) = v1 {

19957

        let v6 = &C::raw_operand_size_of_type(ctx, v2);

19958

        let v7 = C::put_in_reg(ctx, arg2);

19959

        let v8 = C::put_in_reg(ctx, arg3);

19960

        let v9 = &constructor_reg_to_gpr_mem_imm(ctx, v7);

19961

        let v10 = C::gpr_new(ctx, v8);

19962

        let v11 = &constructor_x64_cmp(ctx, v6, v9, v10);

19963

        let v12 = &C::reg_to_gpr_mem(ctx, v8);

19964

        let v13 = C::gpr_new(ctx, v7);

19965

        let v14 = &constructor_cmove(ctx, v2, arg1, v12, v13);

19966

        let v15 = constructor_with_flags_reg(ctx, v11, v14);

19967

        let v16 = C::value_reg(ctx, v15);

19968

        // Rule at src/isa/x64/lower.isle line 1620.

19969

        return v16;

19970

19971

    unreachable!(

19972

        "no rule matched for term {} at {}; should it be partial?",

19973

        "cmp_and_choose", "src/isa/x64/lower.isle line 1619"

19974

19975

19976

19977

// Generated as internal constructor for term has_pmins.

19978

pub fn constructor_has_pmins<C: Context>(ctx: &mut C, arg0: Type) -> bool {

19979

    match arg0 {

19980

        I16X8 => {

19981

            // Rule at src/isa/x64/lower.isle line 1646.

19982

            return true;

19983

19984

        I64X2 => {

19985

            // Rule at src/isa/x64/lower.isle line 1647.

19986

            return false;

19987

19988

        _ => {}

19989

19990

    let v3 = C::use_sse41(ctx);

19991

    // Rule at src/isa/x64/lower.isle line 1648.

19992

    return v3;

19993

19994

19995

// Generated as internal constructor for term has_pmaxs.

19996

pub fn constructor_has_pmaxs<C: Context>(ctx: &mut C, arg0: Type) -> bool {

19997

    match arg0 {

19998

        I16X8 => {

19999

            // Rule at src/isa/x64/lower.isle line 1651.

20000

            return true;

20001

20002

        I64X2 => {

20003

            // Rule at src/isa/x64/lower.isle line 1652.

20004

            return false;

20005

20006

        _ => {}

20007

20008

    let v3 = C::use_sse41(ctx);

20009

    // Rule at src/isa/x64/lower.isle line 1653.

20010

    return v3;

20011

20012

20013

// Generated as internal constructor for term has_pmaxu.

20014

pub fn constructor_has_pmaxu<C: Context>(ctx: &mut C, arg0: Type) -> bool {

20015

    match arg0 {

20016

        I8X16 => {

20017

            // Rule at src/isa/x64/lower.isle line 1656.

20018

            return true;

20019

20020

        I64X2 => {

20021

            // Rule at src/isa/x64/lower.isle line 1657.

20022

            return false;

20023

20024

        _ => {}

20025

20026

    let v3 = C::use_sse41(ctx);

20027

    // Rule at src/isa/x64/lower.isle line 1658.

20028

    return v3;

20029

20030

20031

// Generated as internal constructor for term has_pminu.

20032

pub fn constructor_has_pminu<C: Context>(ctx: &mut C, arg0: Type) -> bool {

20033

    match arg0 {

20034

        I8X16 => {

20035

            // Rule at src/isa/x64/lower.isle line 1661.

20036

            return true;

20037

20038

        I64X2 => {

20039

            // Rule at src/isa/x64/lower.isle line 1662.

20040

            return false;

20041

20042

        _ => {}

20043

20044

    let v3 = C::use_sse41(ctx);

20045

    // Rule at src/isa/x64/lower.isle line 1663.

20046

    return v3;

20047

20048

20049

// Generated as internal constructor for term lower_vec_smax.

20050

pub fn constructor_lower_vec_smax<C: Context>(

20051

    ctx: &mut C,

20052

    arg0: Type,

20053

    arg1: Xmm,

20054

    arg2: Xmm,

20055

) -> Xmm {

20056

    let v3 = constructor_has_pmaxs(ctx, arg0);

20057

    if v3 == true {

20058

        let v4 = &C::xmm_to_xmm_mem(ctx, arg2);

20059

        let v5 = constructor_x64_pmaxs(ctx, arg0, arg1, v4);

20060

        // Rule at src/isa/x64/lower.isle line 1671.

20061

        return v5;

20062

20063

    let v4 = &C::xmm_to_xmm_mem(ctx, arg2);

20064

    let v6 = constructor_x64_pcmpgt(ctx, arg0, arg1, v4);

20065

    let v7 = &C::xmm_to_xmm_mem(ctx, arg1);

20066

    let v8 = constructor_x64_pand(ctx, v6, v7);

20067

    let v9 = &C::xmm_to_xmm_mem(ctx, arg2);

20068

    let v10 = constructor_x64_pandn(ctx, v6, v9);

20069

    let v11 = &C::xmm_to_xmm_mem(ctx, v10);

20070

    let v12 = constructor_x64_por(ctx, v8, v11);

20071

    // Rule at src/isa/x64/lower.isle line 1675.

20072

    return v12;

20073

20074

20075

// Generated as internal constructor for term flip_high_bit_mask.

20076

pub fn constructor_flip_high_bit_mask<C: Context>(ctx: &mut C, arg0: Type) -> Xmm {

20077

    match arg0 {

20078

        I16X8 => {

20079

            let v2 = C::emit_u128_le_const(ctx, 0x80008000800080008000800080008000);

20080

            let v3 = &constructor_const_to_xmm_mem(ctx, v2);

20081

            let v4 = constructor_x64_movdqu_load(ctx, v3);

20082

            // Rule at src/isa/x64/lower.isle line 1730.

20083

            return v4;

20084

20085

        I32X4 => {

20086

            let v6 = C::emit_u128_le_const(ctx, 0x80000000800000008000000080000000);

20087

            let v7 = &constructor_const_to_xmm_mem(ctx, v6);

20088

            let v8 = constructor_x64_movdqu_load(ctx, v7);

20089

            // Rule at src/isa/x64/lower.isle line 1732.

20090

            return v8;

20091

20092

        I64X2 => {

20093

            let v10 = C::emit_u128_le_const(ctx, 0x80000000000000008000000000000000);

20094

            let v11 = &constructor_const_to_xmm_mem(ctx, v10);

20095

            let v12 = constructor_x64_movdqu_load(ctx, v11);

20096

            // Rule at src/isa/x64/lower.isle line 1734.

20097

            return v12;

20098

20099

        _ => {}

20100

20101

    unreachable!(

20102

        "no rule matched for term {} at {}; should it be partial?",

20103

        "flip_high_bit_mask", "src/isa/x64/lower.isle line 1729"

20104

20105

20106

20107

// Generated as internal constructor for term lower_select_fcmp.

20108

pub fn constructor_lower_select_fcmp<C: Context>(

20109

    ctx: &mut C,

20110

    arg0: Type,

20111

    arg1: &FcmpCondResult,

20112

    arg2: Value,

20113

    arg3: Value,

20114

) -> InstOutput {

20115

    match arg1 {

20116

        &FcmpCondResult::Condition {

20117

            producer: ref v2,

20118

            cc: ref v3,

20119

        } => {

20120

            let v6 = &constructor_cmove_from_values(ctx, arg0, v3, arg2, arg3);

20121

            let v7 = constructor_with_flags(ctx, v2, v6);

20122

            let v8 = C::output(ctx, v7);

20123

            // Rule at src/isa/x64/lower.isle line 2053.

20124

            return v8;

20125

20126

        &FcmpCondResult::OrCondition {

20127

            producer: ref v9,

20128

            cc1: ref v10,

20129

            cc2: ref v11,

20130

        } => {

20131

            let v12 = &constructor_cmove_or_from_values(ctx, arg0, v10, v11, arg2, arg3);

20132

            let v13 = constructor_with_flags(ctx, v9, v12);

20133

            let v14 = C::output(ctx, v13);

20134

            // Rule at src/isa/x64/lower.isle line 2055.

20135

            return v14;

20136

20137

        _ => {}

20138

20139

    unreachable!(

20140

        "no rule matched for term {} at {}; should it be partial?",

20141

        "lower_select_fcmp", "src/isa/x64/lower.isle line 2052"

20142

20143

20144

20145

// Generated as internal constructor for term do_clz.

20146

pub fn constructor_do_clz<C: Context>(ctx: &mut C, arg0: Type, arg1: Type, arg2: Gpr) -> Gpr {

20147

    let v5 = constructor_imm_i64(ctx, I64, -0x1);

20148

    let v6 = C::gpr_new(ctx, v5);

20149

    let v7 = constructor_bsr_or_else(ctx, arg0, arg2, v6);

20150

    let v8 = C::gpr_to_reg(ctx, v7);

20151

    let v9 = C::ty_bits_u64(ctx, arg1);

20152

    let v11 = C::u64_sub(ctx, v9, 0x1);

20153

    let v12 = constructor_imm(ctx, arg0, v11);

20154

    let v13 = C::gpr_new(ctx, v12);

20155

    let v14 = &constructor_reg_to_gpr_mem_imm(ctx, v8);

20156

    let v15 = constructor_x64_sub(ctx, arg0, v13, v14);

20157

    // Rule at src/isa/x64/lower.isle line 2126.

20158

    return v15;

20159

20160

20161

// Generated as internal constructor for term do_ctz.

20162

pub fn constructor_do_ctz<C: Context>(ctx: &mut C, arg0: Type, arg1: Type, arg2: Gpr) -> Gpr {

20163

    let v4 = C::ty_bits_u64(ctx, arg1);

20164

    let v5 = constructor_imm(ctx, I64, v4);

20165

    let v6 = C::gpr_new(ctx, v5);

20166

    let v7 = constructor_bsf_or_else(ctx, arg0, arg2, v6);

20167

    // Rule at src/isa/x64/lower.isle line 2162.

20168

    return v7;

20169

20170

20171

// Generated as internal constructor for term do_popcnt.

20172

pub fn constructor_do_popcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {

20173

    match arg0 {

20174

        I32 => {

20175

            let v4 = Imm8Reg::Imm8 { imm: 0x1 };

20176

            let v5 = &C::imm8_reg_to_imm8_gpr(ctx, &v4);

20177

            let v47 = constructor_x64_shr(ctx, I32, arg1, v5);

20178

            let v49 = constructor_imm(ctx, I32, 0x77777777);

20179

            let v50 = C::gpr_new(ctx, v49);

20180

            let v51 = &C::gpr_to_gpr_mem_imm(ctx, v50);

20181

            let v52 = constructor_x64_and(ctx, I32, v47, v51);

20182

            let v53 = &C::gpr_to_gpr_mem_imm(ctx, v52);

20183

            let v54 = constructor_x64_sub(ctx, I32, arg1, v53);

20184

            let v14 = &C::imm8_reg_to_imm8_gpr(ctx, &v4);

20185

            let v55 = constructor_x64_shr(ctx, I32, v52, v14);

20186

            let v56 = &C::gpr_to_gpr_mem_imm(ctx, v50);

20187

            let v57 = constructor_x64_and(ctx, I32, v55, v56);

20188

            let v58 = &C::gpr_to_gpr_mem_imm(ctx, v57);

20189

            let v59 = constructor_x64_sub(ctx, I32, v54, v58);

20190

            let v20 = &C::imm8_reg_to_imm8_gpr(ctx, &v4);

20191

            let v60 = constructor_x64_shr(ctx, I32, v57, v20);

20192

            let v61 = &C::gpr_to_gpr_mem_imm(ctx, v50);

20193

            let v62 = constructor_x64_and(ctx, I32, v60, v61);

20194

            let v63 = &C::gpr_to_gpr_mem_imm(ctx, v62);

20195

            let v64 = constructor_x64_sub(ctx, I32, v59, v63);

20196

            let v27 = Imm8Reg::Imm8 { imm: 0x4 };

20197

            let v28 = &C::imm8_reg_to_imm8_gpr(ctx, &v27);

20198

            let v65 = constructor_x64_shr(ctx, I32, v64, v28);

20199

            let v66 = &C::gpr_to_gpr_mem_imm(ctx, v64);

20200

            let v67 = constructor_x64_add(ctx, I32, v65, v66);

20201

            let v69 = RegMemImm::Imm { simm32: 0xF0F0F0F };

20202

            let v70 = &C::gpr_mem_imm_new(ctx, &v69);

20203

            let v71 = constructor_x64_and(ctx, I32, v67, v70);

20204

            let v73 = RegMemImm::Imm { simm32: 0x1010101 };

20205

            let v74 = &C::gpr_mem_imm_new(ctx, &v73);

20206

            let v75 = constructor_x64_mul(ctx, I32, v71, v74);

20207

            let v77 = Imm8Reg::Imm8 { imm: 0x18 };

20208

            let v78 = &C::imm8_reg_to_imm8_gpr(ctx, &v77);

20209

            let v79 = constructor_x64_shr(ctx, I32, v75, v78);

20210

            // Rule at src/isa/x64/lower.isle line 2244.

20211

            return v79;

20212

20213

        I64 => {

20214

            let v4 = Imm8Reg::Imm8 { imm: 0x1 };

20215

            let v5 = &C::imm8_reg_to_imm8_gpr(ctx, &v4);

20216

            let v6 = constructor_x64_shr(ctx, I64, arg1, v5);

20217

            let v8 = constructor_imm(ctx, I64, 0x7777777777777777);

20218

            let v9 = C::gpr_new(ctx, v8);

20219

            let v10 = &C::gpr_to_gpr_mem_imm(ctx, v9);

20220

            let v11 = constructor_x64_and(ctx, I64, v6, v10);

20221

            let v12 = &C::gpr_to_gpr_mem_imm(ctx, v11);

20222

            let v13 = constructor_x64_sub(ctx, I64, arg1, v12);

20223

            let v14 = &C::imm8_reg_to_imm8_gpr(ctx, &v4);

20224

            let v15 = constructor_x64_shr(ctx, I64, v11, v14);

20225

            let v16 = &C::gpr_to_gpr_mem_imm(ctx, v9);

20226

            let v17 = constructor_x64_and(ctx, I64, v15, v16);

20227

            let v18 = &C::gpr_to_gpr_mem_imm(ctx, v17);

20228

            let v19 = constructor_x64_sub(ctx, I64, v13, v18);

20229

            let v20 = &C::imm8_reg_to_imm8_gpr(ctx, &v4);

20230

            let v21 = constructor_x64_shr(ctx, I64, v17, v20);

20231

            let v22 = &C::gpr_to_gpr_mem_imm(ctx, v9);

20232

            let v23 = constructor_x64_and(ctx, I64, v21, v22);

20233

            let v24 = &C::gpr_to_gpr_mem_imm(ctx, v23);

20234

            let v25 = constructor_x64_sub(ctx, I64, v19, v24);

20235

            let v27 = Imm8Reg::Imm8 { imm: 0x4 };

20236

            let v28 = &C::imm8_reg_to_imm8_gpr(ctx, &v27);

20237

            let v29 = constructor_x64_shr(ctx, I64, v25, v28);

20238

            let v30 = &C::gpr_to_gpr_mem_imm(ctx, v25);

20239

            let v31 = constructor_x64_add(ctx, I64, v29, v30);

20240

            let v33 = constructor_imm(ctx, I64, 0xF0F0F0F0F0F0F0F);

20241

            let v34 = C::gpr_new(ctx, v33);

20242

            let v35 = &C::gpr_to_gpr_mem_imm(ctx, v34);

20243

            let v36 = constructor_x64_and(ctx, I64, v31, v35);

20244

            let v38 = constructor_imm(ctx, I64, 0x101010101010101);

20245

            let v39 = C::gpr_new(ctx, v38);

20246

            let v40 = &C::gpr_to_gpr_mem_imm(ctx, v39);

20247

            let v41 = constructor_x64_mul(ctx, I64, v36, v40);

20248

            let v43 = Imm8Reg::Imm8 { imm: 0x38 };

20249

            let v44 = &C::imm8_reg_to_imm8_gpr(ctx, &v43);

20250

            let v45 = constructor_x64_shr(ctx, I64, v41, v44);

20251

            // Rule at src/isa/x64/lower.isle line 2201.

20252

            return v45;

20253

20254

        _ => {}

20255

20256

    unreachable!(

20257

        "no rule matched for term {} at {}; should it be partial?",

20258

        "do_popcnt", "src/isa/x64/lower.isle line 2200"

20259

20260

20261

20262

// Generated as internal constructor for term do_bitrev8.

20263

pub fn constructor_do_bitrev8<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {

20264

    let v2 = C::ty_mask(ctx, arg0);

20265

    let v4 = C::u64_and(ctx, v2, 0x5555555555555555);

20266

    let v5 = constructor_imm(ctx, arg0, v4);

20267

    let v6 = C::gpr_new(ctx, v5);

20268

    let v7 = &C::gpr_to_gpr_mem_imm(ctx, v6);

20269

    let v8 = constructor_x64_and(ctx, arg0, arg1, v7);

20270

    let v10 = Imm8Reg::Imm8 { imm: 0x1 };

20271

    let v11 = &C::imm8_reg_to_imm8_gpr(ctx, &v10);

20272

    let v12 = constructor_x64_shr(ctx, arg0, arg1, v11);

20273

    let v13 = &C::gpr_to_gpr_mem_imm(ctx, v6);

20274

    let v14 = constructor_x64_and(ctx, arg0, v12, v13);

20275

    let v15 = &C::imm8_reg_to_imm8_gpr(ctx, &v10);

20276

    let v16 = constructor_x64_shl(ctx, arg0, v8, v15);

20277

    let v17 = &C::gpr_to_gpr_mem_imm(ctx, v14);

20278

    let v18 = constructor_x64_or(ctx, arg0, v16, v17);

20279

    let v20 = C::u64_and(ctx, v2, 0x3333333333333333);

20280

    let v21 = constructor_imm(ctx, arg0, v20);

20281

    let v22 = C::gpr_new(ctx, v21);

20282

    let v23 = &C::gpr_to_gpr_mem_imm(ctx, v22);

20283

    let v24 = constructor_x64_and(ctx, arg0, v18, v23);

20284

    let v26 = Imm8Reg::Imm8 { imm: 0x2 };

20285

    let v27 = &C::imm8_reg_to_imm8_gpr(ctx, &v26);

20286

    let v28 = constructor_x64_shr(ctx, arg0, v18, v27);

20287

    let v29 = &C::gpr_to_gpr_mem_imm(ctx, v22);

20288

    let v30 = constructor_x64_and(ctx, arg0, v28, v29);

20289

    let v31 = &C::imm8_reg_to_imm8_gpr(ctx, &v26);

20290

    let v32 = constructor_x64_shl(ctx, arg0, v24, v31);

20291

    let v33 = &C::gpr_to_gpr_mem_imm(ctx, v30);

20292

    let v34 = constructor_x64_or(ctx, arg0, v32, v33);

20293

    let v36 = C::u64_and(ctx, v2, 0xF0F0F0F0F0F0F0F);

20294

    let v37 = constructor_imm(ctx, arg0, v36);

20295

    let v38 = C::gpr_new(ctx, v37);

20296

    let v39 = &C::gpr_to_gpr_mem_imm(ctx, v38);

20297

    let v40 = constructor_x64_and(ctx, arg0, v34, v39);

20298

    let v42 = Imm8Reg::Imm8 { imm: 0x4 };

20299

    let v43 = &C::imm8_reg_to_imm8_gpr(ctx, &v42);

20300

    let v44 = constructor_x64_shr(ctx, arg0, v34, v43);

20301

    let v45 = &C::gpr_to_gpr_mem_imm(ctx, v38);

20302

    let v46 = constructor_x64_and(ctx, arg0, v44, v45);

20303

    let v47 = &C::imm8_reg_to_imm8_gpr(ctx, &v42);

20304

    let v48 = constructor_x64_shl(ctx, arg0, v40, v47);

20305

    let v49 = &C::gpr_to_gpr_mem_imm(ctx, v46);

20306

    let v50 = constructor_x64_or(ctx, arg0, v48, v49);

20307

    // Rule at src/isa/x64/lower.isle line 2338.

20308

    return v50;

20309

20310

20311

// Generated as internal constructor for term do_bitrev16.

20312

pub fn constructor_do_bitrev16<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {

20313

    let v2 = constructor_do_bitrev8(ctx, arg0, arg1);

20314

    let v3 = C::ty_mask(ctx, arg0);

20315

    let v5 = C::u64_and(ctx, v3, 0xFF00FF00FF00FF);

20316

    let v6 = constructor_imm(ctx, arg0, v5);

20317

    let v7 = C::gpr_new(ctx, v6);

20318

    let v8 = &C::gpr_to_gpr_mem_imm(ctx, v7);

20319

    let v9 = constructor_x64_and(ctx, arg0, v2, v8);

20320

    let v11 = Imm8Reg::Imm8 { imm: 0x8 };

20321

    let v12 = &C::imm8_reg_to_imm8_gpr(ctx, &v11);

20322

    let v13 = constructor_x64_shr(ctx, arg0, v2, v12);

20323

    let v14 = &C::gpr_to_gpr_mem_imm(ctx, v7);

20324

    let v15 = constructor_x64_and(ctx, arg0, v13, v14);

20325

    let v16 = &C::imm8_reg_to_imm8_gpr(ctx, &v11);

20326

    let v17 = constructor_x64_shl(ctx, arg0, v9, v16);

20327

    let v18 = &C::gpr_to_gpr_mem_imm(ctx, v15);

20328

    let v19 = constructor_x64_or(ctx, arg0, v17, v18);

20329

    // Rule at src/isa/x64/lower.isle line 2361.

20330

    return v19;

20331

20332

20333

// Generated as internal constructor for term do_bitrev32.

20334

pub fn constructor_do_bitrev32<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {

20335

    let v2 = constructor_do_bitrev16(ctx, arg0, arg1);

20336

    let v3 = C::ty_mask(ctx, arg0);

20337

    let v5 = C::u64_and(ctx, v3, 0xFFFF0000FFFF);

20338

    let v6 = constructor_imm(ctx, arg0, v5);

20339

    let v7 = C::gpr_new(ctx, v6);

20340

    let v8 = &C::gpr_to_gpr_mem_imm(ctx, v7);

20341

    let v9 = constructor_x64_and(ctx, arg0, v2, v8);

20342

    let v11 = Imm8Reg::Imm8 { imm: 0x10 };

20343

    let v12 = &C::imm8_reg_to_imm8_gpr(ctx, &v11);

20344

    let v13 = constructor_x64_shr(ctx, arg0, v2, v12);

20345

    let v14 = &C::gpr_to_gpr_mem_imm(ctx, v7);

20346

    let v15 = constructor_x64_and(ctx, arg0, v13, v14);

20347

    let v16 = &C::imm8_reg_to_imm8_gpr(ctx, &v11);

20348

    let v17 = constructor_x64_shl(ctx, arg0, v9, v16);

20349

    let v18 = &C::gpr_to_gpr_mem_imm(ctx, v15);

20350

    let v19 = constructor_x64_or(ctx, arg0, v17, v18);

20351

    // Rule at src/isa/x64/lower.isle line 2373.

20352

    return v19;

20353

20354

20355

// Generated as internal constructor for term do_bitrev64.

20356

pub fn constructor_do_bitrev64<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {

20357

    if arg0 == I64 {

20358

        let v2 = constructor_do_bitrev32(ctx, arg0, arg1);

20359

        let v4 = constructor_imm(ctx, arg0, 0xFFFFFFFF);

20360

        let v5 = C::gpr_new(ctx, v4);

20361

        let v6 = &C::gpr_to_gpr_mem_imm(ctx, v5);

20362

        let v7 = constructor_x64_and(ctx, arg0, v2, v6);

20363

        let v9 = Imm8Reg::Imm8 { imm: 0x20 };

20364

        let v10 = &C::imm8_reg_to_imm8_gpr(ctx, &v9);

20365

        let v11 = constructor_x64_shr(ctx, arg0, v2, v10);

20366

        let v12 = &C::imm8_reg_to_imm8_gpr(ctx, &v9);

20367

        let v13 = constructor_x64_shl(ctx, arg0, v7, v12);

20368

        let v14 = &C::gpr_to_gpr_mem_imm(ctx, v11);

20369

        let v15 = constructor_x64_or(ctx, arg0, v13, v14);

20370

        // Rule at src/isa/x64/lower.isle line 2385.

20371

        return v15;

20372

20373

    unreachable!(

20374

        "no rule matched for term {} at {}; should it be partial?",

20375

        "do_bitrev64", "src/isa/x64/lower.isle line 2384"

20376

20377

20378

20379

// Generated as internal constructor for term fmadd.

20380

pub fn constructor_fmadd<C: Context>(

20381

    ctx: &mut C,

20382

    arg0: Type,

20383

    arg1: Value,

20384

    arg2: Value,

20385

    arg3: Value,

20386

) -> Xmm {

20387

    let v24 = C::def_inst(ctx, arg2);

20388

    if let Some(v25) = v24 {

20389

        let v26 = &C::inst_data(ctx, v25);

20390

        if let &InstructionData::Unary {

20391

            opcode: ref v27,

20392

            arg: v28,

20393

        } = v26

20394

20395

            if let &Opcode::Fneg = v27 {

20396

                let v29 = constructor_fnmadd(ctx, arg0, arg1, v28, arg3);

20397

                // Rule at src/isa/x64/lower.isle line 2819.

20398

                return v29;

20399

20400

20401

20402

    let v18 = C::def_inst(ctx, arg1);

20403

    if let Some(v19) = v18 {

20404

        let v20 = &C::inst_data(ctx, v19);

20405

        if let &InstructionData::Unary {

20406

            opcode: ref v21,

20407

            arg: v22,

20408

        } = v20

20409

20410

            if let &Opcode::Fneg = v21 {

20411

                let v23 = constructor_fnmadd(ctx, arg0, v22, arg2, arg3);

20412

                // Rule at src/isa/x64/lower.isle line 2818.

20413

                return v23;

20414

20415

20416

20417

    let v14 = &C::sinkable_load(ctx, arg2);

20418

    if let Some(v15) = v14 {

20419

        let v4 = constructor_put_in_xmm(ctx, arg1);

20420

        let v11 = constructor_put_in_xmm(ctx, arg3);

20421

        let v16 = &constructor_sink_load_to_xmm_mem(ctx, v15);

20422

        let v17 = constructor_x64_vfmadd132(ctx, arg0, v4, v11, v16);

20423

        // Rule at src/isa/x64/lower.isle line 2814.

20424

        return v17;

20425

20426

    let v8 = &C::sinkable_load(ctx, arg1);

20427

    if let Some(v9) = v8 {

20428

        let v10 = constructor_put_in_xmm(ctx, arg2);

20429

        let v11 = constructor_put_in_xmm(ctx, arg3);

20430

        let v12 = &constructor_sink_load_to_xmm_mem(ctx, v9);

20431

        let v13 = constructor_x64_vfmadd132(ctx, arg0, v10, v11, v12);

20432

        // Rule at src/isa/x64/lower.isle line 2813.

20433

        return v13;

20434

20435

    let v4 = constructor_put_in_xmm(ctx, arg1);

20436

    let v5 = constructor_put_in_xmm(ctx, arg2);

20437

    let v6 = &C::put_in_xmm_mem(ctx, arg3);

20438

    let v7 = constructor_x64_vfmadd213(ctx, arg0, v4, v5, v6);

20439

    // Rule at src/isa/x64/lower.isle line 2808.

20440

    return v7;

20441

20442

20443

// Generated as internal constructor for term fnmadd.

20444

pub fn constructor_fnmadd<C: Context>(

20445

    ctx: &mut C,

20446

    arg0: Type,

20447

    arg1: Value,

20448

    arg2: Value,

20449

    arg3: Value,

20450

) -> Xmm {

20451

    let v24 = C::def_inst(ctx, arg2);

20452

    if let Some(v25) = v24 {

20453

        let v26 = &C::inst_data(ctx, v25);

20454

        if let &InstructionData::Unary {

20455

            opcode: ref v27,

20456

            arg: v28,

20457

        } = v26

20458

20459

            if let &Opcode::Fneg = v27 {

20460

                let v29 = constructor_fmadd(ctx, arg0, arg1, v28, arg3);

20461

                // Rule at src/isa/x64/lower.isle line 2827.

20462

                return v29;

20463

20464

20465

20466

    let v18 = C::def_inst(ctx, arg1);

20467

    if let Some(v19) = v18 {

20468

        let v20 = &C::inst_data(ctx, v19);

20469

        if let &InstructionData::Unary {

20470

            opcode: ref v21,

20471

            arg: v22,

20472

        } = v20

20473

20474

            if let &Opcode::Fneg = v21 {

20475

                let v23 = constructor_fmadd(ctx, arg0, v22, arg2, arg3);

20476

                // Rule at src/isa/x64/lower.isle line 2826.

20477

                return v23;

20478

20479

20480

20481

    let v14 = &C::sinkable_load(ctx, arg2);

20482

    if let Some(v15) = v14 {

20483

        let v4 = constructor_put_in_xmm(ctx, arg1);

20484

        let v11 = constructor_put_in_xmm(ctx, arg3);

20485

        let v16 = &constructor_sink_load_to_xmm_mem(ctx, v15);

20486

        let v17 = constructor_x64_vfnmadd132(ctx, arg0, v4, v11, v16);

20487

        // Rule at src/isa/x64/lower.isle line 2823.

20488

        return v17;

20489

20490

    let v8 = &C::sinkable_load(ctx, arg1);

20491

    if let Some(v9) = v8 {

20492

        let v10 = constructor_put_in_xmm(ctx, arg2);

20493

        let v11 = constructor_put_in_xmm(ctx, arg3);

20494

        let v12 = &constructor_sink_load_to_xmm_mem(ctx, v9);

20495

        let v13 = constructor_x64_vfnmadd132(ctx, arg0, v10, v11, v12);

20496

        // Rule at src/isa/x64/lower.isle line 2822.

20497

        return v13;

20498

20499

    let v4 = constructor_put_in_xmm(ctx, arg1);

20500

    let v5 = constructor_put_in_xmm(ctx, arg2);

20501

    let v6 = &C::put_in_xmm_mem(ctx, arg3);

20502

    let v7 = constructor_x64_vfnmadd213(ctx, arg0, v4, v5, v6);

20503

    // Rule at src/isa/x64/lower.isle line 2821.

20504

    return v7;

20505

20506

20507

// Generated as internal constructor for term cmp_zero_i128.

20508

pub fn constructor_cmp_zero_i128<C: Context>(

20509

    ctx: &mut C,

20510

    arg0: &CC,

20511

    arg1: ValueRegs,

20512

) -> IcmpCondResult {

20513

    let v1 = &C::cc_nz_or_z(ctx, arg0);

20514

    if let Some(v2) = v1 {

20515

        let v5 = constructor_value_regs_get_gpr(ctx, arg1, 0x0);

20516

        let v7 = constructor_value_regs_get_gpr(ctx, arg1, 0x1);

20517

        let v10 = RegMemImm::Imm { simm32: 0x0 };

20518

        let v11 = &C::gpr_mem_imm_new(ctx, &v10);

20519

        let v12 = &constructor_x64_cmp(ctx, &OperandSize::Size64, v11, v5);

20520

        let v14 = &constructor_x64_setcc(ctx, &CC::Z);

20521

        let v15 = constructor_with_flags_reg(ctx, v12, v14);

20522

        let v16 = C::gpr_new(ctx, v15);

20523

        let v17 = &C::gpr_mem_imm_new(ctx, &v10);

20524

        let v18 = &constructor_x64_cmp(ctx, &OperandSize::Size64, v17, v7);

20525

        let v19 = &constructor_x64_setcc(ctx, &CC::Z);

20526

        let v20 = constructor_with_flags_reg(ctx, v18, v19);

20527

        let v21 = C::gpr_new(ctx, v20);

20528

        let v23 = &C::gpr_to_gpr_mem_imm(ctx, v16);

20529

        let v24 = &constructor_x64_test(ctx, &OperandSize::Size8, v23, v21);

20530

        let v25 = &constructor_icmp_cond_result(ctx, v24, v2);

20531

        // Rule at src/isa/x64/lower.isle line 3295.

20532

        return v25.clone();

20533

20534

    unreachable!(

20535

        "no rule matched for term {} at {}; should it be partial?",

20536

        "cmp_zero_i128", "src/isa/x64/lower.isle line 3294"

20537

20538

20539

20540

// Generated as internal constructor for term cmp_zero_int_bool_ref.

20541

pub fn constructor_cmp_zero_int_bool_ref<C: Context>(ctx: &mut C, arg0: Value) -> ProducesFlags {

20542

    let v1 = C::value_type(ctx, arg0);

20543

    let v2 = &C::raw_operand_size_of_type(ctx, v1);

20544

    let v3 = constructor_put_in_gpr(ctx, arg0);

20545

    let v4 = &C::gpr_to_gpr_mem_imm(ctx, v3);

20546

    let v5 = &constructor_x64_test(ctx, v2, v4, v3);

20547

    // Rule at src/isa/x64/lower.isle line 3306.

20548

    return v5.clone();

20549

20550

20551

// Generated as internal constructor for term lower_swiden_low.

20552

pub fn constructor_lower_swiden_low<C: Context>(ctx: &mut C, arg0: Type, arg1: Xmm) -> Xmm {

20553

    match arg0 {

20554

        I16X8 => {

20555

            let v2 = &C::xmm_to_xmm_mem(ctx, arg1);

20556

            let v3 = constructor_x64_punpcklbw(ctx, arg1, v2);

20557

            let v5 = &C::xmi_imm(ctx, 0x8);

20558

            let v6 = constructor_x64_psraw(ctx, v3, v5);

20559

            // Rule at src/isa/x64/lower.isle line 3720.

20560

            return v6;

20561

20562

        I32X4 => {

20563

            let v2 = &C::xmm_to_xmm_mem(ctx, arg1);

20564

            let v7 = constructor_x64_punpcklwd(ctx, arg1, v2);

20565

            let v9 = &C::xmi_imm(ctx, 0x10);

20566

            let v10 = constructor_x64_psrad(ctx, v7, v9);

20567

            // Rule at src/isa/x64/lower.isle line 3722.

20568

            return v10;

20569

20570

        I64X2 => {

20571

            let v12 = constructor_xmm_zero(ctx, I32X4);

20572

            let v13 = &C::xmm_to_xmm_mem(ctx, arg1);

20573

            let v14 = constructor_x64_pcmpgtd(ctx, v12, v13);

20574

            let v15 = &C::xmm_to_xmm_mem(ctx, v14);

20575

            let v16 = constructor_x64_punpckldq(ctx, arg1, v15);

20576

            // Rule at src/isa/x64/lower.isle line 3728.

20577

            return v16;

20578

20579

        _ => {}

20580

20581

    unreachable!(

20582

        "no rule matched for term {} at {}; should it be partial?",

20583

        "lower_swiden_low", "src/isa/x64/lower.isle line 3715"

20584

20585

20586

20587

// Generated as internal constructor for term lower_uwiden_low.

20588

pub fn constructor_lower_uwiden_low<C: Context>(ctx: &mut C, arg0: Type, arg1: Xmm) -> Xmm {

20589

    match arg0 {

20590

        I16X8 => {

20591

            let v3 = constructor_xmm_zero(ctx, I8X16);

20592

            let v4 = &C::xmm_to_xmm_mem(ctx, v3);

20593

            let v5 = constructor_x64_punpcklbw(ctx, arg1, v4);

20594

            // Rule at src/isa/x64/lower.isle line 3783.

20595

            return v5;

20596

20597

        I32X4 => {

20598

            let v3 = constructor_xmm_zero(ctx, I8X16);

20599

            let v4 = &C::xmm_to_xmm_mem(ctx, v3);

20600

            let v6 = constructor_x64_punpcklwd(ctx, arg1, v4);

20601

            // Rule at src/isa/x64/lower.isle line 3784.

20602

            return v6;

20603

20604

        I64X2 => {

20605

            let v8 = constructor_xmm_zero(ctx, F32X4);

20606

            let v9 = &C::xmm_to_xmm_mem(ctx, v8);

20607

            let v10 = constructor_x64_unpcklps(ctx, arg1, v9);

20608

            // Rule at src/isa/x64/lower.isle line 3785.

20609

            return v10;

20610

20611

        _ => {}

20612

20613

    unreachable!(

20614

        "no rule matched for term {} at {}; should it be partial?",

20615

        "lower_uwiden_low", "src/isa/x64/lower.isle line 3782"

20616

20617

20618

20619

// Generated as internal constructor for term unarrow_i32x4_lanes_to_low_u16_lanes.

20620

pub fn constructor_unarrow_i32x4_lanes_to_low_u16_lanes<C: Context>(ctx: &mut C, arg0: Xmm) -> Xmm {

20621

    let v2 = constructor_xmm_zero(ctx, I32X4);

20622

    let v3 = &C::xmm_to_xmm_mem(ctx, v2);

20623

    let v4 = constructor_x64_pcmpgtd(ctx, arg0, v3);

20624

    let v5 = &C::xmm_to_xmm_mem(ctx, v4);

20625

    let v6 = constructor_x64_pand(ctx, arg0, v5);

20626

    let v8 = C::emit_u128_le_const(ctx, 0xFFFF0000FFFF0000FFFF0000FFFF);

20627

    let v9 = &constructor_const_to_xmm_mem(ctx, v8);

20628

    let v10 = constructor_x64_movdqu_load(ctx, v9);

20629

    let v11 = &C::xmm_to_xmm_mem(ctx, v6);

20630

    let v12 = constructor_x64_pcmpgtd(ctx, v10, v11);

20631

    let v13 = &C::xmm_to_xmm_mem(ctx, v12);

20632

    let v14 = constructor_x64_pand(ctx, v6, v13);

20633

    let v15 = &C::xmm_to_xmm_mem(ctx, v10);

20634

    let v16 = constructor_x64_pandn(ctx, v12, v15);

20635

    let v17 = &C::xmm_to_xmm_mem(ctx, v16);

20636

    let v18 = constructor_x64_por(ctx, v14, v17);

20637

    let v19 = &C::xmm_to_xmm_mem(ctx, v18);

20638

    let v21 = constructor_x64_pshuflw(ctx, v19, 0x8);

20639

    let v22 = &C::xmm_to_xmm_mem(ctx, v21);

20640

    let v23 = constructor_x64_pshufhw(ctx, v22, 0x8);

20641

    let v24 = &C::xmm_to_xmm_mem(ctx, v23);

20642

    let v25 = constructor_x64_pshufd(ctx, v24, 0x8);

20643

    // Rule at src/isa/x64/lower.isle line 3865.

20644

    return v25;

20645

20646

20647

// Generated as internal constructor for term x64_round.

20648

pub fn constructor_x64_round<C: Context>(

20649

    ctx: &mut C,

20650

    arg0: Type,

20651

    arg1: &RegMem,

20652

    arg2: &RoundImm,

20653

) -> Xmm {

20654

    match arg0 {

20655

        F32 => {

20656

            let v3 = C::use_sse41(ctx);

20657

            if v3 == true {

20658

                let v4 = &C::reg_mem_to_xmm_mem(ctx, arg1);

20659

                let v5 = constructor_x64_roundss(ctx, v4, arg2);

20660

                // Rule at src/isa/x64/lower.isle line 3933.

20661

                return v5;

20662

20663

            if let &RegMem::Reg { reg: v9 } = arg1 {

20664

                let v11 = &constructor_round_libcall(ctx, F32, arg2);

20665

                let v12 = C::libcall_1(ctx, v11, v9);

20666

                let v13 = C::xmm_new(ctx, v12);

20667

                // Rule at src/isa/x64/lower.isle line 3946.

20668

                return v13;

20669

20670

20671

        F64 => {

20672

            let v3 = C::use_sse41(ctx);

20673

            if v3 == true {

20674

                let v4 = &C::reg_mem_to_xmm_mem(ctx, arg1);

20675

                let v6 = constructor_x64_roundsd(ctx, v4, arg2);

20676

                // Rule at src/isa/x64/lower.isle line 3936.

20677

                return v6;

20678

20679

            if let &RegMem::Reg { reg: v9 } = arg1 {

20680

                let v15 = &constructor_round_libcall(ctx, F64, arg2);

20681

                let v16 = C::libcall_1(ctx, v15, v9);

20682

                let v17 = C::xmm_new(ctx, v16);

20683

                // Rule at src/isa/x64/lower.isle line 3947.

20684

                return v17;

20685

20686

20687

        F32X4 => {

20688

            let v3 = C::use_sse41(ctx);

20689

            if v3 == true {

20690

                let v4 = &C::reg_mem_to_xmm_mem(ctx, arg1);

20691

                let v7 = constructor_x64_roundps(ctx, v4, arg2);

20692

                // Rule at src/isa/x64/lower.isle line 3939.

20693

                return v7;

20694

20695

            if let &RegMem::Reg { reg: v9 } = arg1 {

20696

                let v11 = &constructor_round_libcall(ctx, F32, arg2);

20697

                let v12 = C::libcall_1(ctx, v11, v9);

20698

                let v13 = C::xmm_new(ctx, v12);

20699

                let v18 = &constructor_reg_to_xmm_mem(ctx, v9);

20700

                let v20 = constructor_x64_pshufd(ctx, v18, 0x1);

20701

                let v21 = C::xmm_to_reg(ctx, v20);

20702

                let v22 = C::libcall_1(ctx, v11, v21);

20703

                let v23 = C::xmm_new(ctx, v22);

20704

                let v25 = C::xmm_to_reg(ctx, v23);

20705

                let v26 = &constructor_xmm_to_reg_mem(ctx, v25);

20706

                let v27 = &C::xmm_mem_to_reg_mem(ctx, v26);

20707

                let v28 = constructor_vec_insert_lane(ctx, F32X4, v13, v27, 0x1);

20708

                let v29 = &constructor_reg_to_xmm_mem(ctx, v9);

20709

                let v31 = constructor_x64_pshufd(ctx, v29, 0x2);

20710

                let v32 = C::xmm_to_reg(ctx, v31);

20711

                let v33 = C::libcall_1(ctx, v11, v32);

20712

                let v34 = C::xmm_new(ctx, v33);

20713

                let v35 = C::xmm_to_reg(ctx, v34);

20714

                let v36 = &constructor_xmm_to_reg_mem(ctx, v35);

20715

                let v37 = &C::xmm_mem_to_reg_mem(ctx, v36);

20716

                let v38 = constructor_vec_insert_lane(ctx, F32X4, v28, v37, 0x2);

20717

                let v39 = &constructor_reg_to_xmm_mem(ctx, v9);

20718

                let v41 = constructor_x64_pshufd(ctx, v39, 0x3);

20719

                let v42 = C::xmm_to_reg(ctx, v41);

20720

                let v43 = C::libcall_1(ctx, v11, v42);

20721

                let v44 = C::xmm_new(ctx, v43);

20722

                let v45 = C::xmm_to_reg(ctx, v44);

20723

                let v46 = &constructor_xmm_to_reg_mem(ctx, v45);

20724

                let v47 = &C::xmm_mem_to_reg_mem(ctx, v46);

20725

                let v48 = constructor_vec_insert_lane(ctx, F32X4, v38, v47, 0x3);

20726

                // Rule at src/isa/x64/lower.isle line 3948.

20727

                return v48;

20728

20729

20730

        F64X2 => {

20731

            let v3 = C::use_sse41(ctx);

20732

            if v3 == true {

20733

                let v4 = &C::reg_mem_to_xmm_mem(ctx, arg1);

20734

                let v8 = constructor_x64_roundpd(ctx, v4, arg2);

20735

                // Rule at src/isa/x64/lower.isle line 3942.

20736

                return v8;

20737

20738

            if let &RegMem::Reg { reg: v9 } = arg1 {

20739

                let v15 = &constructor_round_libcall(ctx, F64, arg2);

20740

                let v16 = C::libcall_1(ctx, v15, v9);

20741

                let v17 = C::xmm_new(ctx, v16);

20742

                let v18 = &constructor_reg_to_xmm_mem(ctx, v9);

20743

                let v50 = constructor_x64_pshufd(ctx, v18, 0xE);

20744

                let v51 = C::xmm_to_reg(ctx, v50);

20745

                let v52 = C::libcall_1(ctx, v15, v51);

20746

                let v53 = C::xmm_new(ctx, v52);

20747

                let v55 = C::xmm_to_reg(ctx, v53);

20748

                let v56 = &constructor_xmm_to_reg_mem(ctx, v55);

20749

                let v57 = &C::xmm_mem_to_reg_mem(ctx, v56);

20750

                let v58 = constructor_vec_insert_lane(ctx, F64X2, v17, v57, 0x1);

20751

                // Rule at src/isa/x64/lower.isle line 3960.

20752

                return v58;

20753

20754

20755

        _ => {}

20756

20757

    if let &RegMem::Mem { addr: ref v59 } = arg1 {

20758

        let v61 = constructor_x64_load(ctx, arg0, v59, &ExtKind::ZeroExtend);

20759

        let v62 = RegMem::Reg { reg: v61 };

20760

        let v63 = constructor_x64_round(ctx, arg0, &v62, arg2);

20761

        // Rule at src/isa/x64/lower.isle line 3968.

20762

        return v63;

20763

20764

    unreachable!(

20765

        "no rule matched for term {} at {}; should it be partial?",

20766

        "x64_round", "src/isa/x64/lower.isle line 3932"

20767

20768

20769

20770

// Generated as internal constructor for term round_libcall.

20771

pub fn constructor_round_libcall<C: Context>(ctx: &mut C, arg0: Type, arg1: &RoundImm) -> LibCall {

20772

    match arg0 {

20773

        F32 => {

20774

            match arg1 {

20775

                &RoundImm::RoundNearest => {

20776

                    // Rule at src/isa/x64/lower.isle line 3976.

20777

                    return LibCall::NearestF32;

20778

20779

                &RoundImm::RoundDown => {

20780

                    // Rule at src/isa/x64/lower.isle line 3974.

20781

                    return LibCall::FloorF32;

20782

20783

                &RoundImm::RoundUp => {

20784

                    // Rule at src/isa/x64/lower.isle line 3972.

20785

                    return LibCall::CeilF32;

20786

20787

                &RoundImm::RoundZero => {

20788

                    // Rule at src/isa/x64/lower.isle line 3978.

20789

                    return LibCall::TruncF32;

20790

20791

                _ => {}

20792

20793

20794

        F64 => {

20795

            match arg1 {

20796

                &RoundImm::RoundNearest => {

20797

                    // Rule at src/isa/x64/lower.isle line 3977.

20798

                    return LibCall::NearestF64;

20799

20800

                &RoundImm::RoundDown => {

20801

                    // Rule at src/isa/x64/lower.isle line 3975.

20802

                    return LibCall::FloorF64;

20803

20804

                &RoundImm::RoundUp => {

20805

                    // Rule at src/isa/x64/lower.isle line 3973.

20806

                    return LibCall::CeilF64;

20807

20808

                &RoundImm::RoundZero => {

20809

                    // Rule at src/isa/x64/lower.isle line 3979.

20810

                    return LibCall::TruncF64;

20811

20812

                _ => {}

20813

20814

20815

        _ => {}

20816

20817

    unreachable!(

20818

        "no rule matched for term {} at {}; should it be partial?",

20819

        "round_libcall", "src/isa/x64/lower.isle line 3971"

20820

20821

20822

20823

// Generated as internal constructor for term nonzero_sdiv_divisor.

20824

pub fn constructor_nonzero_sdiv_divisor<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Reg {

20825

    let v2 = C::def_inst(ctx, arg1);

20826

    if let Some(v3) = v2 {

20827

        let v4 = &C::inst_data(ctx, v3);

20828

        if let &InstructionData::UnaryImm {

20829

            opcode: ref v5,

20830

            imm: v6,

20831

        } = v4

20832

20833

            if let &Opcode::Iconst = v5 {

20834

                let v7 = C::safe_divisor_from_imm64(ctx, arg0, v6);

20835

                if let Some(v8) = v7 {

20836

                    let v9 = constructor_imm(ctx, arg0, v8);

20837

                    // Rule at src/isa/x64/lower.isle line 4059.

20838

                    return v9;

20839

20840

20841

20842

20843

    let v10 = C::put_in_reg(ctx, arg1);

20844

    let v11 = &C::raw_operand_size_of_type(ctx, arg0);

20845

    let v12 = &constructor_reg_to_gpr_mem_imm(ctx, v10);

20846

    let v13 = C::gpr_new(ctx, v10);

20847

    let v14 = &constructor_x64_test(ctx, v11, v12, v13);

20848

    let v17 = &constructor_trap_if(ctx, &CC::Z, &TrapCode::IntegerDivisionByZero);

20849

    let v18 = &constructor_with_flags_side_effect(ctx, v14, v17);

20850

    let v19 = constructor_side_effect(ctx, v18);

20851

    // Rule at src/isa/x64/lower.isle line 4062.

20852

    return v10;

20853

20854

20855

// Generated as internal constructor for term lower_pshufb.

20856

pub fn constructor_lower_pshufb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &RegMem) -> Xmm {

20857

    let v2 = C::use_ssse3(ctx);

20858

    if v2 == true {

20859

        let v3 = &C::reg_mem_to_xmm_mem(ctx, arg1);

20860

        let v4 = constructor_x64_pshufb(ctx, arg0, v3);

20861

        // Rule at src/isa/x64/lower.isle line 4357.

20862

        return v4;

20863

20864

    match arg1 {

20865

        &RegMem::Reg { reg: v5 } => {

20866

            let v7 = C::xmm_to_reg(ctx, arg0);

20867

            let v8 = C::libcall_2(ctx, &LibCall::X86Pshufb, v7, v5);

20868

            let v9 = C::xmm_new(ctx, v8);

20869

            // Rule at src/isa/x64/lower.isle line 4360.

20870

            return v9;

20871

20872

        &RegMem::Mem { addr: ref v10 } => {

20873

            let v11 = &constructor_synthetic_amode_to_xmm_mem(ctx, v10);

20874

            let v12 = constructor_x64_movdqu_load(ctx, v11);

20875

            let v13 = C::xmm_to_reg(ctx, v12);

20876

            let v14 = &constructor_xmm_to_reg_mem(ctx, v13);

20877

            let v15 = &C::xmm_mem_to_reg_mem(ctx, v14);

20878

            let v16 = constructor_lower_pshufb(ctx, arg0, v15);

20879

            // Rule at src/isa/x64/lower.isle line 4362.

20880

            return v16;

20881

20882

        _ => {}

20883

20884

    unreachable!(

20885

        "no rule matched for term {} at {}; should it be partial?",

20886

        "lower_pshufb", "src/isa/x64/lower.isle line 4356"

20887

20888